def __new__(self, xml_state, target_dir, root_dir, custom_args=None):
requested_image_type = xml_state.get_build_type_name()
if requested_image_type in Defaults.get_filesystem_image_types():
return FileSystemBuilder(
xml_state, target_dir, root_dir
)
elif requested_image_type in Defaults.get_disk_image_types():
return DiskBuilder(
xml_state, target_dir, root_dir, custom_args
)
elif requested_image_type in Defaults.get_live_image_types():
return LiveImageBuilder(
xml_state, target_dir, root_dir, custom_args
)
elif requested_image_type in Defaults.get_kis_image_types():
return KisBuilder(
xml_state, target_dir, root_dir, custom_args
)
elif requested_image_type in Defaults.get_archive_image_types():
return ArchiveBuilder(
xml_state, target_dir, root_dir, custom_args
)
elif requested_image_type in Defaults.get_container_image_types():
return ContainerBuilder(
xml_state, target_dir, root_dir, custom_args
)
else:
raise KiwiRequestedTypeError(
'requested image type %s not supported' % requested_image_type
)
def test_setup_ix86(self):
Defaults.set_platform_name('i686')
description = XMLDescription(
'../data/example_disk_config.xml'
)
disk_builder = DiskBuilder(
XMLState(description.load()), 'target_dir', 'root_dir'
)
assert disk_builder.arch == 'ix86'
def test_setup_ix86(self, mock_machine):
mock_machine.return_value = 'i686'
description = XMLDescription(
'../data/example_disk_config.xml'
)
disk_builder = DiskBuilder(
XMLState(description.load()), 'target_dir', 'root_dir'
)
assert disk_builder.arch == 'ix86'
def setup(self, mock_machine, mock_exists):
mock_machine.return_value = 'x86_64'
mock_exists.return_value = True
description = XMLDescription('../data/example_disk_config.xml')
self.device_map = {
'root': MappedDevice('/dev/root-device', mock.Mock()),
'readonly': MappedDevice('/dev/readonly-root-device', mock.Mock()),
'boot': MappedDevice('/dev/boot-device', mock.Mock()),
'prep': MappedDevice('/dev/prep-device', mock.Mock()),
'efi': MappedDevice('/dev/efi-device', mock.Mock())
}
self.id_map = {'kiwi_RootPart': 1, 'kiwi_BootPart': 1}
self.id_map_sorted = OrderedDict(sorted(self.id_map.items()))
self.block_operation = mock.Mock()
self.block_operation.get_blkid = mock.Mock(return_value='blkid_result')
self.block_operation.get_filesystem = mock.Mock(
return_value='filesystem')
kiwi.builder.disk.BlockID = mock.Mock(
return_value=self.block_operation)
self.loop_provider = mock.Mock()
kiwi.builder.disk.LoopDevice = mock.Mock(
return_value=self.loop_provider)
self.disk = mock.Mock()
provider = mock.Mock()
provider.get_device = mock.Mock(return_value='/dev/some-loop')
self.disk.storage_provider = provider
self.partitioner = mock.Mock()
self.partitioner.get_id = mock.Mock(return_value=1)
self.disk.partitioner = self.partitioner
self.disk.get_uuid = mock.Mock(return_value='0815')
self.disk.get_public_partition_id_map = mock.Mock(
return_value=self.id_map_sorted)
self.disk.get_device = mock.Mock(return_value=self.device_map)
kernel_info = mock.Mock()
kernel_info.version = '1.2.3'
kernel_info.name = 'vmlinuz-1.2.3-default'
self.kernel = mock.Mock()
self.kernel.get_kernel = mock.Mock(return_value=kernel_info)
self.kernel.get_xen_hypervisor = mock.Mock()
self.kernel.copy_kernel = mock.Mock()
self.kernel.copy_xen_hypervisor = mock.Mock()
kiwi.builder.disk.Kernel = mock.Mock(return_value=self.kernel)
self.disk.subformat = mock.Mock()
self.disk.subformat.get_target_name_for_format = mock.Mock(
return_value='some-target-format-name')
kiwi.builder.disk.DiskFormat = mock.Mock(
return_value=self.disk.subformat)
kiwi.builder.disk.Disk = mock.Mock(return_value=self.disk)
self.disk_setup = mock.Mock()
self.disk_setup.get_efi_label = mock.Mock(return_value='EFI')
self.disk_setup.get_root_label = mock.Mock(return_value='ROOT')
self.disk_setup.get_boot_label = mock.Mock(return_value='BOOT')
self.disk_setup.need_boot_partition = mock.Mock(return_value=True)
self.bootloader_install = mock.Mock()
kiwi.builder.disk.BootLoaderInstall = mock.MagicMock(
return_value=self.bootloader_install)
self.bootloader_config = mock.Mock()
kiwi.builder.disk.BootLoaderConfig = mock.MagicMock(
return_value=self.bootloader_config)
kiwi.builder.disk.DiskSetup = mock.MagicMock(
return_value=self.disk_setup)
self.boot_image_task = mock.Mock()
self.boot_image_task.boot_root_directory = 'boot_dir'
self.boot_image_task.kernel_filename = 'kernel'
self.boot_image_task.initrd_filename = 'initrd'
self.boot_image_task.xen_hypervisor_filename = 'xen_hypervisor'
kiwi.builder.disk.BootImage = mock.Mock(
return_value=self.boot_image_task)
self.firmware = mock.Mock()
self.firmware.efi_mode = mock.Mock(return_value='efi')
kiwi.builder.disk.FirmWare = mock.Mock(return_value=self.firmware)
self.setup = mock.Mock()
kiwi.builder.disk.SystemSetup = mock.Mock(return_value=self.setup)
self.boot_image_kiwi = mock.Mock()
self.boot_image_kiwi.boot_root_directory = 'boot_dir_kiwi'
kiwi.builder.disk.BootImageKiwi = mock.Mock(
return_value=self.boot_image_kiwi)
self.install_image = mock.Mock()
kiwi.builder.disk.InstallImageBuilder = mock.Mock(
return_value=self.install_image)
self.raid_root = mock.Mock()
kiwi.builder.disk.RaidDevice = mock.Mock(return_value=self.raid_root)
self.luks_root = mock.Mock()
kiwi.builder.disk.LuksDevice = mock.Mock(return_value=self.luks_root)
self.disk_builder = DiskBuilder(
XMLState(description.load()),
'target_dir',
'root_dir',
custom_args={'signing_keys': ['key_file_a', 'key_file_b']})
self.disk_builder.root_filesystem_is_overlay = False
self.disk_builder.build_type_name = 'oem'
self.disk_builder.image_format = None
class TestDiskBuilder(object):
@patch('os.path.exists')
@patch('platform.machine')
def setup(self, mock_machine, mock_exists):
mock_machine.return_value = 'x86_64'
mock_exists.return_value = True
description = XMLDescription('../data/example_disk_config.xml')
self.device_map = {
'root': MappedDevice('/dev/root-device', mock.Mock()),
'readonly': MappedDevice('/dev/readonly-root-device', mock.Mock()),
'boot': MappedDevice('/dev/boot-device', mock.Mock()),
'prep': MappedDevice('/dev/prep-device', mock.Mock()),
'efi': MappedDevice('/dev/efi-device', mock.Mock())
}
self.id_map = {'kiwi_RootPart': 1, 'kiwi_BootPart': 1}
self.id_map_sorted = OrderedDict(sorted(self.id_map.items()))
self.block_operation = mock.Mock()
self.block_operation.get_blkid = mock.Mock(return_value='blkid_result')
self.block_operation.get_filesystem = mock.Mock(
return_value='filesystem')
kiwi.builder.disk.BlockID = mock.Mock(
return_value=self.block_operation)
self.loop_provider = mock.Mock()
kiwi.builder.disk.LoopDevice = mock.Mock(
return_value=self.loop_provider)
self.disk = mock.Mock()
provider = mock.Mock()
provider.get_device = mock.Mock(return_value='/dev/some-loop')
self.disk.storage_provider = provider
self.partitioner = mock.Mock()
self.partitioner.get_id = mock.Mock(return_value=1)
self.disk.partitioner = self.partitioner
self.disk.get_uuid = mock.Mock(return_value='0815')
self.disk.get_public_partition_id_map = mock.Mock(
return_value=self.id_map_sorted)
self.disk.get_device = mock.Mock(return_value=self.device_map)
kernel_info = mock.Mock()
kernel_info.version = '1.2.3'
kernel_info.name = 'vmlinuz-1.2.3-default'
self.kernel = mock.Mock()
self.kernel.get_kernel = mock.Mock(return_value=kernel_info)
self.kernel.get_xen_hypervisor = mock.Mock()
self.kernel.copy_kernel = mock.Mock()
self.kernel.copy_xen_hypervisor = mock.Mock()
kiwi.builder.disk.Kernel = mock.Mock(return_value=self.kernel)
self.disk.subformat = mock.Mock()
self.disk.subformat.get_target_name_for_format = mock.Mock(
return_value='some-target-format-name')
kiwi.builder.disk.DiskFormat = mock.Mock(
return_value=self.disk.subformat)
kiwi.builder.disk.Disk = mock.Mock(return_value=self.disk)
self.disk_setup = mock.Mock()
self.disk_setup.get_efi_label = mock.Mock(return_value='EFI')
self.disk_setup.get_root_label = mock.Mock(return_value='ROOT')
self.disk_setup.get_boot_label = mock.Mock(return_value='BOOT')
self.disk_setup.need_boot_partition = mock.Mock(return_value=True)
self.bootloader_install = mock.Mock()
kiwi.builder.disk.BootLoaderInstall = mock.MagicMock(
return_value=self.bootloader_install)
self.bootloader_config = mock.Mock()
kiwi.builder.disk.BootLoaderConfig = mock.MagicMock(
return_value=self.bootloader_config)
kiwi.builder.disk.DiskSetup = mock.MagicMock(
return_value=self.disk_setup)
self.boot_image_task = mock.Mock()
self.boot_image_task.boot_root_directory = 'boot_dir'
self.boot_image_task.kernel_filename = 'kernel'
self.boot_image_task.initrd_filename = 'initrd'
self.boot_image_task.xen_hypervisor_filename = 'xen_hypervisor'
kiwi.builder.disk.BootImage = mock.Mock(
return_value=self.boot_image_task)
self.firmware = mock.Mock()
self.firmware.efi_mode = mock.Mock(return_value='efi')
kiwi.builder.disk.FirmWare = mock.Mock(return_value=self.firmware)
self.setup = mock.Mock()
kiwi.builder.disk.SystemSetup = mock.Mock(return_value=self.setup)
self.boot_image_kiwi = mock.Mock()
self.boot_image_kiwi.boot_root_directory = 'boot_dir_kiwi'
kiwi.builder.disk.BootImageKiwi = mock.Mock(
return_value=self.boot_image_kiwi)
self.install_image = mock.Mock()
kiwi.builder.disk.InstallImageBuilder = mock.Mock(
return_value=self.install_image)
self.raid_root = mock.Mock()
kiwi.builder.disk.RaidDevice = mock.Mock(return_value=self.raid_root)
self.luks_root = mock.Mock()
kiwi.builder.disk.LuksDevice = mock.Mock(return_value=self.luks_root)
self.disk_builder = DiskBuilder(
XMLState(description.load()),
'target_dir',
'root_dir',
custom_args={'signing_keys': ['key_file_a', 'key_file_b']})
self.disk_builder.root_filesystem_is_overlay = False
self.disk_builder.build_type_name = 'oem'
self.disk_builder.image_format = None
@patch('os.path.exists')
@patch('platform.machine')
def test_setup_ix86(self, mock_machine, mock_exists):
mock_machine.return_value = 'i686'
description = XMLDescription('../data/example_disk_config.xml')
disk_builder = DiskBuilder(XMLState(description.load()), 'target_dir',
'root_dir')
assert disk_builder.arch == 'ix86'
@raises(KiwiInstallMediaError)
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
def test_create_invalid_type_for_install_media(self, mock_cmd, mock_open,
mock_fs):
self.disk_builder.build_type_name = 'vmx'
self.disk_builder.create_disk()
@raises(KiwiVolumeManagerSetupError)
def test_create_disk_overlay_with_volume_setup_not_supported(self):
self.disk_builder.root_filesystem_is_overlay = True
self.disk_builder.volume_manager_name = 'lvm'
self.disk_builder.create_disk()
@patch_open
@patch('os.path.exists')
@patch('pickle.load')
@patch('kiwi.builder.disk.Path.wipe')
def test_create_install_media(self, mock_wipe, mock_load, mock_path,
mock_open):
result_instance = mock.Mock()
mock_path.return_value = True
self.disk_builder.install_iso = True
self.disk_builder.install_pxe = True
self.disk_builder.create_install_media(result_instance)
self.install_image.create_install_iso.assert_called_once_with()
self.install_image.create_install_pxe_archive.assert_called_once_with()
mock_wipe.assert_called_once_with('target_dir/boot_image.pickledump')
@patch('os.path.exists')
@raises(KiwiInstallMediaError)
def test_create_install_media_no_boot_instance_found(self, mock_path):
result_instance = mock.Mock()
mock_path.return_value = False
self.disk_builder.install_iso = True
self.disk_builder.create_install_media(result_instance)
@patch('os.path.exists')
@patch('pickle.load')
@raises(KiwiInstallMediaError)
def test_create_install_media_pickle_load_error(self, mock_load,
mock_path):
result_instance = mock.Mock()
mock_load.side_effect = Exception
mock_path.return_value = True
self.disk_builder.install_iso = True
self.disk_builder.create_install_media(result_instance)
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('random.randrange')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
@patch('os.path.exists')
def test_create_disk_standard_root_with_kiwi_initrd(
self, mock_path, mock_grub_dir, mock_command, mock_rand, mock_open,
mock_fs):
mock_path.return_value = True
mock_rand.return_value = 15
context_manager_mock = mock.Mock()
mock_open.return_value = context_manager_mock
file_mock = mock.Mock()
enter_mock = mock.Mock()
exit_mock = mock.Mock()
enter_mock.return_value = file_mock
setattr(context_manager_mock, '__enter__', enter_mock)
setattr(context_manager_mock, '__exit__', exit_mock)
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.initrd_system = 'kiwi'
self.disk_builder.create_disk()
self.setup.create_recovery_archive.assert_called_once_with()
call = self.setup.export_modprobe_setup.call_args_list[0]
assert self.setup.export_modprobe_setup.call_args_list[0] == \
call('boot_dir')
self.setup.set_selinux_file_contexts.assert_called_once_with(
'/etc/selinux/targeted/contexts/files/file_contexts')
self.disk_setup.get_disksize_mbytes.assert_called_once_with()
self.loop_provider.create.assert_called_once_with()
self.disk.wipe.assert_called_once_with()
self.disk.create_efi_csm_partition.assert_called_once_with(
self.firmware.get_legacy_bios_partition_size())
self.disk.create_efi_partition.assert_called_once_with(
self.firmware.get_efi_partition_size())
self.disk.create_boot_partition.assert_called_once_with(
self.disk_setup.boot_partition_size())
self.disk.create_prep_partition.assert_called_once_with(
self.firmware.get_prep_partition_size())
self.disk.create_root_partition.assert_called_once_with('all_free')
self.disk.map_partitions.assert_called_once_with()
self.bootloader_config.setup_disk_boot_images.assert_called_once_with(
'0815')
self.bootloader_config.setup_disk_image_config.assert_called_once_with(
initrd='initrd.vmx',
kernel='linux.vmx',
boot_uuid='0815',
root_uuid='0815')
self.setup.call_edit_boot_config_script.assert_called_once_with(
'btrfs', 1)
self.bootloader_install.install.assert_called_once_with()
self.setup.call_edit_boot_install_script.assert_called_once_with(
'target_dir/LimeJeOS-openSUSE-13.2.x86_64-1.13.2.raw',
'/dev/boot-device')
self.boot_image_task.prepare.assert_called_once_with()
call = filesystem.create_on_device.call_args_list[0]
assert filesystem.create_on_device.call_args_list[0] == \
call(label='EFI')
call = filesystem.create_on_device.call_args_list[1]
assert filesystem.create_on_device.call_args_list[1] == \
call(label='BOOT')
call = filesystem.create_on_device.call_args_list[2]
assert filesystem.create_on_device.call_args_list[2] == \
call(label='ROOT')
call = filesystem.sync_data.call_args_list[0]
assert filesystem.sync_data.call_args_list[0] == \
call()
call = filesystem.sync_data.call_args_list[1]
assert filesystem.sync_data.call_args_list[1] == \
call(['efi/*'])
call = filesystem.sync_data.call_args_list[2]
assert filesystem.sync_data.call_args_list[2] == \
call([
'image', '.profile', '.kconfig', '.buildenv', 'var/cache/kiwi',
'boot/*', 'boot/.*', 'boot/efi/*', 'boot/efi/.*'
])
assert mock_open.call_args_list[0:3] == [
call('boot_dir/config.partids', 'w'),
call('root_dir/boot/mbrid', 'w'),
call('/dev/some-loop', 'wb')
]
assert file_mock.write.call_args_list == [
call('kiwi_BootPart="1"\n'),
call('kiwi_RootPart="1"\n'),
call('0x0f0f0f0f\n'),
call(bytes(b'\x0f\x0f\x0f\x0f')),
]
assert mock_command.call_args_list == [
call(['cp', 'root_dir/recovery.partition.size', 'boot_dir']),
call(['mv', 'initrd', 'root_dir/boot/initrd.vmx']),
]
self.setup.export_package_list.assert_called_once_with('target_dir')
self.setup.export_package_verification.assert_called_once_with(
'target_dir')
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('random.randrange')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
@patch('os.path.exists')
def test_create_disk_standard_root_with_dracut_initrd(
self, mock_path, mock_grub_dir, mock_command, mock_rand, mock_open,
mock_fs):
mock_path.return_value = True
mock_rand.return_value = 15
context_manager_mock = mock.Mock()
mock_open.return_value = context_manager_mock
file_mock = mock.Mock()
enter_mock = mock.Mock()
exit_mock = mock.Mock()
enter_mock.return_value = file_mock
setattr(context_manager_mock, '__enter__', enter_mock)
setattr(context_manager_mock, '__exit__', exit_mock)
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.initrd_system = 'dracut'
self.disk_builder.create_disk()
self.setup.create_recovery_archive.assert_called_once_with()
call = self.setup.export_modprobe_setup.call_args_list[0]
assert self.setup.export_modprobe_setup.call_args_list[0] == \
call('boot_dir')
call = self.setup.export_modprobe_setup.call_args_list[1]
assert self.setup.export_modprobe_setup.call_args_list[1] == \
call('boot_dir_kiwi')
self.setup.set_selinux_file_contexts.assert_called_once_with(
'/etc/selinux/targeted/contexts/files/file_contexts')
self.disk_setup.get_disksize_mbytes.assert_called_once_with()
self.loop_provider.create.assert_called_once_with()
self.disk.wipe.assert_called_once_with()
self.disk.create_efi_csm_partition.assert_called_once_with(
self.firmware.get_legacy_bios_partition_size())
self.disk.create_efi_partition.assert_called_once_with(
self.firmware.get_efi_partition_size())
self.disk.create_boot_partition.assert_called_once_with(
self.disk_setup.boot_partition_size())
self.disk.create_prep_partition.assert_called_once_with(
self.firmware.get_prep_partition_size())
self.disk.create_root_partition.assert_called_once_with('all_free')
self.disk.map_partitions.assert_called_once_with()
self.bootloader_config.setup_disk_boot_images.assert_called_once_with(
'0815')
self.bootloader_config.setup_disk_image_config.assert_called_once_with(
initrd='initramfs-1.2.3.img',
kernel='vmlinuz-1.2.3-default',
boot_uuid='0815',
root_uuid='0815')
self.setup.call_edit_boot_config_script.assert_called_once_with(
'btrfs', 1)
self.bootloader_install.install.assert_called_once_with()
self.setup.call_edit_boot_install_script.assert_called_once_with(
'target_dir/LimeJeOS-openSUSE-13.2.x86_64-1.13.2.raw',
'/dev/boot-device')
self.boot_image_kiwi.prepare.assert_called_once_with()
self.boot_image_task.prepare.assert_called_once_with()
call = filesystem.create_on_device.call_args_list[0]
assert filesystem.create_on_device.call_args_list[0] == \
call(label='EFI')
call = filesystem.create_on_device.call_args_list[1]
assert filesystem.create_on_device.call_args_list[1] == \
call(label='BOOT')
call = filesystem.create_on_device.call_args_list[2]
assert filesystem.create_on_device.call_args_list[2] == \
call(label='ROOT')
call = filesystem.sync_data.call_args_list[0]
assert filesystem.sync_data.call_args_list[0] == \
call()
call = filesystem.sync_data.call_args_list[1]
assert filesystem.sync_data.call_args_list[1] == \
call(['efi/*'])
call = filesystem.sync_data.call_args_list[2]
assert filesystem.sync_data.call_args_list[2] == \
call([
'image', '.profile', '.kconfig', '.buildenv', 'var/cache/kiwi',
'boot/*', 'boot/.*', 'boot/efi/*', 'boot/efi/.*'
])
assert mock_open.call_args_list == [
call('root_dir/boot/mbrid', 'w'),
call('/dev/some-loop', 'wb'),
call('boot_dir_kiwi/config.partids', 'w')
]
assert file_mock.write.call_args_list == [
call('0x0f0f0f0f\n'),
call(bytes(b'\x0f\x0f\x0f\x0f')),
call('kiwi_BootPart="1"\n'),
call('kiwi_RootPart="1"\n')
]
assert mock_command.call_args_list == [
call(['cp', 'root_dir/recovery.partition.size', 'boot_dir']),
call(['mv', 'initrd', 'root_dir/boot/initramfs-1.2.3.img']),
call(['cp', 'root_dir/recovery.partition.size', 'boot_dir_kiwi'])
]
self.setup.export_package_list.assert_called_once_with('target_dir')
self.setup.export_package_verification.assert_called_once_with(
'target_dir')
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
@patch('kiwi.builder.disk.Path.which')
@patch('kiwi.builder.disk.re.findall')
def test_create_disk_standard_root_dracut_initrd_system(
self, mock_re_findall, mock_which, mock_grub_dir, mock_command,
mock_open, mock_fs):
mock_re_findall.return_value = ['initrd-$kernel']
mock_which.return_value = 'dracut_found'
self.disk_builder.initrd_system = 'dracut'
self.disk_builder.volume_manager_name = None
kernel = mock.Mock()
kernel.version = '1.2.3'
kernel.name = 'vmlinuz-1.2.3'
self.kernel.get_kernel.return_value = kernel
self.disk_builder.create_disk()
self.bootloader_config.setup_disk_image_config.assert_called_once_with(
initrd='initrd-1.2.3',
kernel=kernel.name,
boot_uuid='0815',
root_uuid='0815')
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_standard_root_dracut_initramfs_system(
self, mock_grub_dir, mock_command, mock_open, mock_fs):
self.disk_builder.initrd_system = 'dracut'
self.disk_builder.volume_manager_name = None
kernel = mock.Mock()
kernel.version = '1.2.3'
kernel.name = 'vmlinuz-1.2.3'
self.kernel.get_kernel.return_value = kernel
self.disk_builder.create_disk()
self.bootloader_config.setup_disk_image_config.assert_called_once_with(
initrd='initramfs-1.2.3.img',
kernel=kernel.name,
boot_uuid='0815',
root_uuid='0815')
@patch('kiwi.builder.disk.FileSystem')
@patch('kiwi.builder.disk.FileSystemSquashFs')
@patch_open
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
@patch('os.path.exists')
@patch('os.path.getsize')
@patch('kiwi.builder.disk.NamedTemporaryFile')
def test_create_disk_standard_root_is_overlay(self, mock_temp,
mock_getsize, mock_exists,
mock_grub_dir, mock_command,
mock_open, mock_squashfs,
mock_fs):
self.disk_builder.root_filesystem_is_overlay = True
self.disk_builder.volume_manager_name = None
squashfs = mock.Mock()
mock_squashfs.return_value = squashfs
mock_getsize.return_value = 1048576
tempfile = mock.Mock()
tempfile.name = 'tempname'
mock_temp.return_value = tempfile
mock_exists.return_value = True
self.disk_builder.create_disk()
assert mock_squashfs.call_args_list == [
call(device_provider=None, root_dir='root_dir'),
call(device_provider=None, root_dir='root_dir')
]
assert squashfs.create_on_file.call_args_list == [
call(exclude=['var/cache/kiwi'], filename='tempname'),
call(exclude=[
'image', '.profile', '.kconfig', '.buildenv', 'var/cache/kiwi',
'boot/*', 'boot/.*', 'boot/efi/*', 'boot/efi/.*'
],
filename='tempname')
]
self.disk.create_root_readonly_partition.assert_called_once_with(51)
assert mock_command.call_args_list.pop() == call(
['dd', 'if=tempname', 'of=/dev/readonly-root-device'])
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_standard_root_dracut_initrd_system_on_arm(
self, mock_grub_dir, mock_command, mock_open, mock_fs):
self.disk_builder.initrd_system = 'dracut'
self.disk_builder.arch = 'aarch64'
self.disk_builder.volume_manager_name = None
kernel = mock.Mock()
kernel.version = '1.2.3'
kernel.name = 'Image-1.2.3-default'
self.kernel.get_kernel.return_value = kernel
self.disk_builder.create_disk()
self.bootloader_config.setup_disk_image_config.assert_called_once_with(
initrd='initramfs-1.2.3.img',
kernel=kernel.name,
boot_uuid='0815',
root_uuid='0815')
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
@raises(KiwiDiskBootImageError)
def test_create_disk_standard_root_no_kernel_found(self, mock_command,
mock_open, mock_fs):
self.kernel.get_kernel.return_value = False
self.disk_builder.volume_manager_name = None
self.disk_builder.create_disk()
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
@raises(KiwiDiskBootImageError)
def test_create_disk_standard_root_no_hypervisor_found(
self, mock_command, mock_open, mock_fs):
self.kernel.get_xen_hypervisor.return_value = False
self.disk_builder.volume_manager_name = None
self.disk_builder.xen_server = True
self.disk_builder.create_disk()
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
def test_create_disk_standard_root_xen_server_boot(self, mock_command,
mock_open, mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.xen_server = True
self.firmware.efi_mode = mock.Mock(return_value=False)
self.disk_builder.create_disk()
self.kernel.copy_xen_hypervisor.assert_called_once_with(
'root_dir', '/boot/xen.gz')
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_standard_root_s390_boot(self, mock_grub_dir,
mock_command, mock_open,
mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.firmware.efi_mode = mock.Mock(return_value=False)
self.disk_builder.bootloader = 'grub2_s390x_emu'
self.disk_builder.create_disk()
assert mock_fs.call_args_list[1] == call('ext2',
self.device_map['boot'],
'root_dir/boot/zipl/')
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_standard_root_secure_boot(self, mock_grub_dir,
mock_command, mock_open,
mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.firmware.efi_mode = mock.Mock(return_value='uefi')
self.disk_builder.create_disk()
bootloader = self.bootloader_config
bootloader.setup_disk_boot_images.assert_called_once_with('0815')
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_mdraid_root(self, mock_grub_dir, mock_command,
mock_open, mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.mdraid = 'mirroring'
self.disk_builder.create_disk()
self.disk.create_root_raid_partition.assert_called_once_with(
'all_free')
self.raid_root.create_degraded_raid.assert_called_once_with(
raid_level='mirroring')
self.raid_root.create_raid_config.assert_called_once_with(
'boot_dir/etc/mdadm.conf')
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_luks_root(self, mock_grub_dir, mock_command,
mock_open, mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.luks = 'passphrase'
self.disk_builder.create_disk()
self.luks_root.create_crypto_luks.assert_called_once_with(
passphrase='passphrase', os=None)
self.luks_root.create_crypttab.assert_called_once_with(
'root_dir/etc/crypttab')
@patch('kiwi.builder.disk.FileSystem')
@patch('kiwi.builder.disk.VolumeManager')
@patch_open
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
@patch('os.path.exists')
def test_create_disk_volume_managed_root(self, mock_exists, mock_grub_dir,
mock_command, mock_open,
mock_volume_manager, mock_fs):
mock_exists.return_value = True
volume_manager = mock.Mock()
volume_manager.get_device = mock.Mock(
return_value={
'root': MappedDevice('/dev/systemVG/LVRoot', mock.Mock())
})
volume_manager.get_fstab = mock.Mock(
return_value=['fstab_volume_entries'])
mock_volume_manager.return_value = volume_manager
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = 'lvm'
self.disk_builder.create_disk()
self.disk.create_root_lvm_partition.assert_called_once_with('all_free')
volume_manager.setup.assert_called_once_with('systemVG')
volume_manager.create_volumes.assert_called_once_with('btrfs')
volume_manager.mount_volumes.call_args_list[0].assert_called_once_with(
)
volume_manager.get_fstab.assert_called_once_with(None, 'btrfs')
volume_manager.sync_data.assert_called_once_with([
'image', '.profile', '.kconfig', '.buildenv', 'var/cache/kiwi',
'boot/*', 'boot/.*', 'boot/efi/*', 'boot/efi/.*'
])
volume_manager.umount_volumes.call_args_list[
0].assert_called_once_with()
self.setup.create_fstab.assert_called_once_with([
'fstab_volume_entries', 'UUID=blkid_result / filesystem ro 0 0',
'UUID=blkid_result /boot filesystem defaults 0 0',
'UUID=blkid_result /boot/efi filesystem defaults 0 0'
])
self.boot_image_task.setup.create_fstab.assert_called_once_with([
'fstab_volume_entries', 'UUID=blkid_result / filesystem ro 0 0',
'UUID=blkid_result /boot filesystem defaults 0 0',
'UUID=blkid_result /boot/efi filesystem defaults 0 0'
])
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_hybrid_gpt_requested(self, mock_grub_dir,
mock_command, mock_open,
mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.install_media = False
self.disk_builder.hybrid_mbr = True
self.disk_builder.create_disk()
self.disk.create_hybrid_mbr.assert_called_once_with()
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_force_mbr_requested(self, mock_grub_dir, mock_command,
mock_open, mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.install_media = False
self.disk_builder.force_mbr = True
self.disk_builder.create_disk()
self.disk.create_mbr.assert_called_once_with()
@patch('kiwi.builder.disk.DiskBuilder')
def test_create(self, mock_builder):
result = mock.Mock()
builder = mock.Mock()
builder.create_disk.return_value = result
builder.create_install_media.return_value = result
mock_builder.return_value = builder
self.disk_builder.create()
builder.create_disk.assert_called_once_with()
builder.create_install_media.assert_called_once_with(result)
builder.create_disk_format.assert_called_once_with(result)
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_spare_part_requested(self, mock_grub_dir,
mock_command, mock_open,
mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.install_media = False
self.disk_builder.spare_part_mbsize = 42
self.disk_builder.create_disk()
self.disk.create_spare_partition.assert_called_once_with(42)
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
def test_create_disk_format(self, mock_command, mock_open, mock_fs):
result_instance = mock.Mock()
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.install_media = False
self.disk_builder.image_format = 'vmdk'
self.disk_builder.create_disk_format(result_instance)
self.disk.subformat.create_image_format.assert_called_once_with()
def setup(self, mock_exists):
Defaults.set_platform_name('x86_64')
def side_effect(filename):
if filename.endswith('.config/kiwi/config.yml'):
return False
elif filename.endswith('etc/kiwi.yml'):
return False
else:
return True
mock_exists.side_effect = side_effect
description = XMLDescription(
'../data/example_disk_config.xml'
)
self.device_map = {
'root': MappedDevice('/dev/root-device', Mock()),
'swap': MappedDevice('/dev/swap-device', Mock()),
'readonly': MappedDevice('/dev/readonly-root-device', Mock()),
'boot': MappedDevice('/dev/boot-device', Mock()),
'prep': MappedDevice('/dev/prep-device', Mock()),
'efi': MappedDevice('/dev/efi-device', Mock()),
'spare': MappedDevice('/dev/spare-device', Mock()),
'var': MappedDevice('/dev/spare-device', Mock())
}
self.id_map = {
'kiwi_RootPart': 1,
'kiwi_BootPart': 1
}
self.id_map_sorted = OrderedDict(
sorted(self.id_map.items())
)
self.boot_names_type = namedtuple(
'boot_names_type', ['kernel_name', 'initrd_name']
)
self.block_operation = Mock()
self.block_operation.get_blkid = Mock(
return_value='blkid_result'
)
self.block_operation.get_filesystem = Mock(
return_value='blkid_result_fs'
)
kiwi.builder.disk.BlockID = Mock(
return_value=self.block_operation
)
self.loop_provider = Mock()
kiwi.builder.disk.LoopDevice = Mock(
return_value=self.loop_provider
)
self.disk = Mock()
provider = Mock()
provider.get_device = Mock(
return_value='/dev/some-loop'
)
self.disk.storage_provider = provider
self.partitioner = Mock()
self.partitioner.get_id = Mock(
return_value=1
)
self.disk.partitioner = self.partitioner
self.disk.get_uuid = Mock(
return_value='0815'
)
self.disk.get_public_partition_id_map = Mock(
return_value=self.id_map_sorted
)
self.disk.get_device = Mock(
return_value=self.device_map
)
kernel_info = Mock()
kernel_info.version = '1.2.3'
kernel_info.name = 'vmlinuz-1.2.3-default'
self.kernel = Mock()
self.kernel.get_kernel = Mock(
return_value=kernel_info
)
self.kernel.get_xen_hypervisor = Mock()
self.kernel.copy_kernel = Mock()
self.kernel.copy_xen_hypervisor = Mock()
kiwi.builder.disk.Kernel = Mock(
return_value=self.kernel
)
kiwi.builder.disk.Disk = Mock(
return_value=self.disk
)
self.disk_setup = Mock()
self.disk_setup.get_disksize_mbytes.return_value = 1024
self.disk_setup.boot_partition_size.return_value = 0
self.disk_setup.get_efi_label = Mock(
return_value='EFI'
)
self.disk_setup.get_root_label = Mock(
return_value='ROOT'
)
self.disk_setup.get_boot_label = Mock(
return_value='BOOT'
)
self.disk_setup.need_boot_partition = Mock(
return_value=True
)
self.bootloader_install = Mock()
kiwi.builder.disk.BootLoaderInstall.new = MagicMock(
return_value=self.bootloader_install
)
self.bootloader_config = Mock()
self.bootloader_config.get_boot_cmdline = Mock(
return_value='boot_cmdline'
)
kiwi.builder.disk.BootLoaderConfig.new = MagicMock(
return_value=self.bootloader_config
)
kiwi.builder.disk.DiskSetup = MagicMock(
return_value=self.disk_setup
)
self.boot_image_task = Mock()
self.boot_image_task.boot_root_directory = 'boot_dir'
self.boot_image_task.kernel_filename = 'kernel'
self.boot_image_task.initrd_filename = 'initrd'
self.boot_image_task.xen_hypervisor_filename = 'xen_hypervisor'
self.boot_image_task.get_boot_names.return_value = self.boot_names_type(
kernel_name='linux.vmx',
initrd_name='initrd.vmx'
)
kiwi.builder.disk.BootImage.new = Mock(
return_value=self.boot_image_task
)
self.firmware = Mock()
self.firmware.get_legacy_bios_partition_size.return_value = 0
self.firmware.get_efi_partition_size.return_value = 0
self.firmware.get_prep_partition_size.return_value = 0
self.firmware.efi_mode = Mock(
return_value='efi'
)
kiwi.builder.disk.FirmWare = Mock(
return_value=self.firmware
)
self.setup = Mock()
kiwi.builder.disk.SystemSetup = Mock(
return_value=self.setup
)
self.install_image = Mock()
kiwi.builder.disk.InstallImageBuilder = Mock(
return_value=self.install_image
)
self.raid_root = Mock()
self.raid_root.get_device.return_value = MappedDevice(
'/dev/md0', Mock()
)
kiwi.builder.disk.RaidDevice = Mock(
return_value=self.raid_root
)
self.luks_root = Mock()
kiwi.builder.disk.LuksDevice = Mock(
return_value=self.luks_root
)
self.fstab = Mock()
kiwi.builder.disk.Fstab = Mock(
return_value=self.fstab
)
self.xml_state = XMLState(description.load())
self.disk_builder = DiskBuilder(
self.xml_state, 'target_dir', 'root_dir',
custom_args={'signing_keys': ['key_file_a', 'key_file_b']}
)
self.disk_builder.bundle_format = '%N'
self.disk_builder.root_filesystem_is_overlay = False
self.disk_builder.build_type_name = 'oem'
self.disk_builder.image_format = None
class TestDiskBuilder:
@fixture(autouse=True)
def inject_fixtures(self, caplog):
self._caplog = caplog
@patch('os.path.exists')
def setup(self, mock_exists):
Defaults.set_platform_name('x86_64')
def side_effect(filename):
if filename.endswith('.config/kiwi/config.yml'):
return False
elif filename.endswith('etc/kiwi.yml'):
return False
else:
return True
mock_exists.side_effect = side_effect
description = XMLDescription(
'../data/example_disk_config.xml'
)
self.device_map = {
'root': MappedDevice('/dev/root-device', Mock()),
'swap': MappedDevice('/dev/swap-device', Mock()),
'readonly': MappedDevice('/dev/readonly-root-device', Mock()),
'boot': MappedDevice('/dev/boot-device', Mock()),
'prep': MappedDevice('/dev/prep-device', Mock()),
'efi': MappedDevice('/dev/efi-device', Mock()),
'spare': MappedDevice('/dev/spare-device', Mock()),
'var': MappedDevice('/dev/spare-device', Mock())
}
self.id_map = {
'kiwi_RootPart': 1,
'kiwi_BootPart': 1
}
self.id_map_sorted = OrderedDict(
sorted(self.id_map.items())
)
self.boot_names_type = namedtuple(
'boot_names_type', ['kernel_name', 'initrd_name']
)
self.block_operation = Mock()
self.block_operation.get_blkid = Mock(
return_value='blkid_result'
)
self.block_operation.get_filesystem = Mock(
return_value='blkid_result_fs'
)
kiwi.builder.disk.BlockID = Mock(
return_value=self.block_operation
)
self.loop_provider = Mock()
kiwi.builder.disk.LoopDevice = Mock(
return_value=self.loop_provider
)
self.disk = Mock()
provider = Mock()
provider.get_device = Mock(
return_value='/dev/some-loop'
)
self.disk.storage_provider = provider
self.partitioner = Mock()
self.partitioner.get_id = Mock(
return_value=1
)
self.disk.partitioner = self.partitioner
self.disk.get_uuid = Mock(
return_value='0815'
)
self.disk.get_public_partition_id_map = Mock(
return_value=self.id_map_sorted
)
self.disk.get_device = Mock(
return_value=self.device_map
)
kernel_info = Mock()
kernel_info.version = '1.2.3'
kernel_info.name = 'vmlinuz-1.2.3-default'
self.kernel = Mock()
self.kernel.get_kernel = Mock(
return_value=kernel_info
)
self.kernel.get_xen_hypervisor = Mock()
self.kernel.copy_kernel = Mock()
self.kernel.copy_xen_hypervisor = Mock()
kiwi.builder.disk.Kernel = Mock(
return_value=self.kernel
)
kiwi.builder.disk.Disk = Mock(
return_value=self.disk
)
self.disk_setup = Mock()
self.disk_setup.get_disksize_mbytes.return_value = 1024
self.disk_setup.boot_partition_size.return_value = 0
self.disk_setup.get_efi_label = Mock(
return_value='EFI'
)
self.disk_setup.get_root_label = Mock(
return_value='ROOT'
)
self.disk_setup.get_boot_label = Mock(
return_value='BOOT'
)
self.disk_setup.need_boot_partition = Mock(
return_value=True
)
self.bootloader_install = Mock()
kiwi.builder.disk.BootLoaderInstall.new = MagicMock(
return_value=self.bootloader_install
)
self.bootloader_config = Mock()
self.bootloader_config.get_boot_cmdline = Mock(
return_value='boot_cmdline'
)
kiwi.builder.disk.BootLoaderConfig.new = MagicMock(
return_value=self.bootloader_config
)
kiwi.builder.disk.DiskSetup = MagicMock(
return_value=self.disk_setup
)
self.boot_image_task = Mock()
self.boot_image_task.boot_root_directory = 'boot_dir'
self.boot_image_task.kernel_filename = 'kernel'
self.boot_image_task.initrd_filename = 'initrd'
self.boot_image_task.xen_hypervisor_filename = 'xen_hypervisor'
self.boot_image_task.get_boot_names.return_value = self.boot_names_type(
kernel_name='linux.vmx',
initrd_name='initrd.vmx'
)
kiwi.builder.disk.BootImage.new = Mock(
return_value=self.boot_image_task
)
self.firmware = Mock()
self.firmware.get_legacy_bios_partition_size.return_value = 0
self.firmware.get_efi_partition_size.return_value = 0
self.firmware.get_prep_partition_size.return_value = 0
self.firmware.efi_mode = Mock(
return_value='efi'
)
kiwi.builder.disk.FirmWare = Mock(
return_value=self.firmware
)
self.setup = Mock()
kiwi.builder.disk.SystemSetup = Mock(
return_value=self.setup
)
self.install_image = Mock()
kiwi.builder.disk.InstallImageBuilder = Mock(
return_value=self.install_image
)
self.raid_root = Mock()
self.raid_root.get_device.return_value = MappedDevice(
'/dev/md0', Mock()
)
kiwi.builder.disk.RaidDevice = Mock(
return_value=self.raid_root
)
self.luks_root = Mock()
kiwi.builder.disk.LuksDevice = Mock(
return_value=self.luks_root
)
self.fstab = Mock()
kiwi.builder.disk.Fstab = Mock(
return_value=self.fstab
)
self.xml_state = XMLState(description.load())
self.disk_builder = DiskBuilder(
self.xml_state, 'target_dir', 'root_dir',
custom_args={'signing_keys': ['key_file_a', 'key_file_b']}
)
self.disk_builder.bundle_format = '%N'
self.disk_builder.root_filesystem_is_overlay = False
self.disk_builder.build_type_name = 'oem'
self.disk_builder.image_format = None
@patch('os.path.exists')
def setup_method(self, cls, mock_exists):
self.setup()
def teardown(self):
sys.argv = argv_kiwi_tests
def teardown_method(self, cls):
self.teardown()
def test_setup_warn_no_initrd_support(self):
self.boot_image_task.has_initrd_support = Mock(
return_value=False
)
with self._caplog.at_level(logging.WARNING):
DiskBuilder(self.xml_state, 'target_dir', 'root_dir')
def test_setup_ix86(self):
Defaults.set_platform_name('i686')
description = XMLDescription(
'../data/example_disk_config.xml'
)
disk_builder = DiskBuilder(
XMLState(description.load()), 'target_dir', 'root_dir'
)
assert disk_builder.arch == 'ix86'
@patch('kiwi.builder.disk.FileSystem.new')
@patch('kiwi.builder.disk.Command.run')
def test_create_invalid_type_for_install_media(
self, mock_cmd, mock_fs
):
self.disk_builder.build_type_name = 'kis'
with patch('builtins.open'):
with raises(KiwiInstallMediaError):
self.disk_builder.create_disk()
def test_create_disk_overlay_with_volume_setup_not_supported(self):
self.disk_builder.root_filesystem_is_overlay = True
self.disk_builder.volume_manager_name = 'lvm'
with raises(KiwiVolumeManagerSetupError):
self.disk_builder.create_disk()
@patch('kiwi.builder.disk.InstallImageBuilder')
def test_create_install_media(
self, mock_install_image
):
result_instance = Mock()
mock_install_image.return_value = self.install_image
self.disk_builder.initrd_system = 'dracut'
self.disk_builder.install_iso = True
self.disk_builder.install_pxe = True
self.disk_builder.create_install_media(result_instance)
self.install_image.create_install_iso.assert_called_once_with()
self.install_image.create_install_pxe_archive.assert_called_once_with()
mock_install_image.assert_called_once_with(
ANY, 'root_dir', 'target_dir', None,
{'signing_keys': ['key_file_a', 'key_file_b']}
)
@patch('kiwi.builder.disk.InstallImageBuilder')
def test_create_install_mediai_custom_boot(
self, mock_install_image
):
result_instance = Mock()
mock_install_image.return_value = self.install_image
self.disk_builder.initrd_system = 'kiwi'
self.disk_builder.install_pxe = True
self.disk_builder.create_install_media(result_instance)
self.install_image.create_install_pxe_archive.assert_called_once_with()
mock_install_image.assert_called_once_with(
ANY, 'root_dir', 'target_dir', ANY,
{'signing_keys': ['key_file_a', 'key_file_b']}
)
@patch('kiwi.builder.disk.FileSystem.new')
@patch('random.randrange')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
@patch('kiwi.builder.disk.ImageSystem')
@patch('os.path.exists')
def test_create_disk_standard_root_with_kiwi_initrd(
self, mock_path, mock_ImageSystem, mock_grub_dir,
mock_command, mock_rand, mock_fs
):
mock_path.return_value = True
mock_rand.return_value = 15
filesystem = Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.initrd_system = 'kiwi'
m_open = mock_open()
with patch('builtins.open', m_open, create=True):
self.disk_builder.create_disk()
self.setup.create_recovery_archive.assert_called_once_with()
call = self.setup.export_modprobe_setup.call_args_list[0]
assert self.setup.export_modprobe_setup.call_args_list[0] == \
call('boot_dir')
self.setup.set_selinux_file_contexts.assert_called_once_with(
'/etc/selinux/targeted/contexts/files/file_contexts'
)
self.disk_setup.get_disksize_mbytes.assert_called_once_with()
self.loop_provider.create.assert_called_once_with()
self.disk.wipe.assert_called_once_with()
self.disk.create_efi_csm_partition.assert_called_once_with(
self.firmware.get_legacy_bios_partition_size()
)
self.disk.create_efi_partition.assert_called_once_with(
self.firmware.get_efi_partition_size()
)
self.disk.create_boot_partition.assert_called_once_with(
self.disk_setup.boot_partition_size()
)
self.disk.create_swap_partition.assert_called_once_with(
'128'
)
self.disk.create_prep_partition.assert_called_once_with(
self.firmware.get_prep_partition_size()
)
self.disk.create_root_partition.assert_called_once_with(
'all_free'
)
self.disk.map_partitions.assert_called_once_with()
self.bootloader_config.setup_disk_boot_images.assert_called_once_with(
'0815'
)
self.bootloader_config.write_meta_data.assert_called_once_with(
root_device='/dev/root-device', boot_options=''
)
self.bootloader_config.setup_disk_image_config.assert_called_once_with(
boot_options={
'boot_device': '/dev/boot-device',
'root_device': '/dev/readonly-root-device',
'firmware': self.firmware,
'target_removable': None,
'efi_device': '/dev/efi-device',
'prep_device': '/dev/prep-device'
}
)
self.setup.call_edit_boot_config_script.assert_called_once_with(
'btrfs', 1
)
self.bootloader_install.install.assert_called_once_with()
self.setup.call_edit_boot_install_script.assert_called_once_with(
'target_dir/LimeJeOS-openSUSE-13.2.x86_64-1.13.2.raw',
'/dev/boot-device'
)
self.boot_image_task.prepare.assert_called_once_with()
call = filesystem.create_on_device.call_args_list[0]
assert filesystem.create_on_device.call_args_list[0] == \
call(label='EFI')
call = filesystem.create_on_device.call_args_list[1]
assert filesystem.create_on_device.call_args_list[1] == \
call(label='BOOT')
call = filesystem.create_on_device.call_args_list[2]
assert filesystem.create_on_device.call_args_list[2] == \
call(label='ROOT')
call = filesystem.sync_data.call_args_list[0]
assert filesystem.sync_data.call_args_list[0] == \
call()
call = filesystem.sync_data.call_args_list[1]
assert filesystem.sync_data.call_args_list[1] == \
call(['efi/*'])
call = filesystem.sync_data.call_args_list[2]
assert filesystem.sync_data.call_args_list[2] == \
call([
'image', '.profile', '.kconfig', 'run/*', 'tmp/*',
'.buildenv', 'var/cache/kiwi', 'boot/*', 'boot/.*',
'boot/efi/*', 'boot/efi/.*'
])
assert m_open.call_args_list[0:4] == [
call('boot_dir/config.partids', 'w'),
call('root_dir/boot/mbrid', 'w'),
call('boot_dir/config.bootoptions', 'w'),
call('/dev/some-loop', 'wb')
]
assert m_open.return_value.write.call_args_list == [
call('kiwi_BootPart="1"\n'),
call('kiwi_RootPart="1"\n'),
call('0x0f0f0f0f\n'),
call('boot_cmdline\n'),
call(bytes(b'\x0f\x0f\x0f\x0f')),
]
assert mock_command.call_args_list == [
call(['cp', 'root_dir/recovery.partition.size', 'boot_dir']),
call(['mv', 'initrd', 'root_dir/boot/initrd.vmx']),
]
self.block_operation.get_blkid.assert_has_calls(
[call('PARTUUID')]
)
self.setup.export_package_list.assert_called_once_with(
'target_dir'
)
self.setup.export_package_verification.assert_called_once_with(
'target_dir'
)
@patch('kiwi.builder.disk.FileSystem.new')
@patch('random.randrange')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
@patch('os.path.exists')
@patch('os.path.getsize')
@patch('kiwi.builder.disk.SystemSetup')
@patch('kiwi.builder.disk.ImageSystem')
@patch('kiwi.builder.disk.VeritySetup')
@patch('kiwi.builder.disk.Temporary.new_file')
def test_create_disk_standard_root_with_dracut_initrd(
self, mock_Temporary_new_file, mock_VeritySetup,
mock_ImageSystem, mock_SystemSetup, mock_os_path_getsize,
mock_path, mock_grub_dir, mock_command, mock_rand, mock_fs
):
tempfile = Mock()
tempfile.name = 'tempfile'
mock_Temporary_new_file.return_value = tempfile
mock_os_path_getsize.return_value = 42
self.boot_image_task.get_boot_names.return_value = self.boot_names_type(
kernel_name='vmlinuz-1.2.3-default',
initrd_name='initramfs-1.2.3.img'
)
mock_path.return_value = True
mock_rand.return_value = 15
filesystem = Mock()
mock_fs.return_value = filesystem
self.disk_builder.root_filesystem_verity_blocks = 10
self.disk_builder.root_filesystem_embed_verity_metadata = True
self.disk_builder.root_filesystem_is_overlay = False
self.disk_builder.volume_manager_name = None
self.disk_builder.initrd_system = 'dracut'
self.setup.script_exists.return_value = True
disk_system = Mock()
mock_SystemSetup.return_value = disk_system
m_open = mock_open()
with patch('builtins.open', m_open, create=True):
self.disk_builder.create_disk()
self.setup.create_recovery_archive.assert_called_once_with()
self.setup.set_selinux_file_contexts.assert_called_once_with(
'/etc/selinux/targeted/contexts/files/file_contexts'
)
self.disk_setup.get_disksize_mbytes.assert_called_once_with()
assert self.loop_provider.create.call_args_list == [
call(), call()
]
self.disk.wipe.assert_called_once_with()
self.disk.create_efi_csm_partition.assert_called_once_with(
self.firmware.get_legacy_bios_partition_size()
)
self.disk.create_efi_partition.assert_called_once_with(
self.firmware.get_efi_partition_size()
)
self.disk.create_boot_partition.assert_called_once_with(
self.disk_setup.boot_partition_size()
)
self.disk.create_prep_partition.assert_called_once_with(
self.firmware.get_prep_partition_size()
)
self.disk.create_root_partition.assert_called_once_with(
'all_free'
)
self.disk.map_partitions.assert_called_once_with()
self.bootloader_config.setup_disk_boot_images.assert_called_once_with(
'0815'
)
self.bootloader_config.write_meta_data.assert_called_once_with(
root_device='/dev/root-device', boot_options=''
)
self.bootloader_config.setup_disk_image_config.assert_called_once_with(
boot_options={
'boot_device': '/dev/boot-device',
'root_device': '/dev/readonly-root-device',
'firmware': self.firmware,
'target_removable': None,
'efi_device': '/dev/efi-device',
'prep_device': '/dev/prep-device'
}
)
assert self.setup.script_exists.call_args_list == [
call('pre_disk_sync.sh'),
call('disk.sh')
]
disk_system.call_pre_disk_script.assert_called_once_with()
disk_system.call_disk_script.assert_called_once_with()
self.setup.call_edit_boot_config_script.assert_called_once_with(
'btrfs', 1
)
self.bootloader_install.install.assert_called_once_with()
self.setup.call_edit_boot_install_script.assert_called_once_with(
'target_dir/LimeJeOS-openSUSE-13.2.x86_64-1.13.2.raw',
'/dev/boot-device'
)
self.boot_image_task.prepare.assert_called_once_with()
assert filesystem.create_on_device.call_args_list[0] == \
call(label='EFI')
assert filesystem.create_on_device.call_args_list[1] == \
call(label='BOOT')
assert filesystem.create_on_device.call_args_list[2] == \
call(label='ROOT')
assert filesystem.sync_data.call_args_list[0] == \
call()
assert filesystem.sync_data.call_args_list[1] == \
call(['efi/*'])
assert filesystem.sync_data.call_args_list[2] == \
call([
'image', '.profile', '.kconfig', 'run/*', 'tmp/*',
'.buildenv', 'var/cache/kiwi', 'boot/*', 'boot/.*',
'boot/efi/*', 'boot/efi/.*'
])
assert m_open.call_args_list == [
call('boot_dir/config.partids', 'w'),
call('root_dir/boot/mbrid', 'w'),
call('boot_dir/config.bootoptions', 'w'),
call('/dev/some-loop', 'wb')
]
assert m_open.return_value.write.call_args_list == [
call('kiwi_BootPart="1"\n'),
call('kiwi_RootPart="1"\n'),
call('0x0f0f0f0f\n'),
call('boot_cmdline\n'),
call(bytes(b'\x0f\x0f\x0f\x0f'))
]
assert mock_command.call_args_list == [
call(['cp', 'root_dir/recovery.partition.size', 'boot_dir']),
call(['mv', 'initrd', 'root_dir/boot/initramfs-1.2.3.img']),
call(['blockdev', '--getsize64', '/dev/root-device']),
call(['dd', 'if=tempfile', 'of=/dev/root-device'])
]
self.block_operation.get_blkid.assert_has_calls(
[call('PARTUUID')]
)
self.setup.export_package_list.assert_called_once_with(
'target_dir'
)
self.setup.export_package_verification.assert_called_once_with(
'target_dir'
)
assert self.boot_image_task.include_file.call_args_list == [
call('/config.partids'),
call('/recovery.partition.size')
]
self.boot_image_task.include_module.assert_called_once_with(
'kiwi-repart'
)
self.boot_image_task.omit_module.assert_called_once_with('multipath')
assert self.boot_image_task.write_system_config_file.call_args_list == \
[]
filesystem.create_verity_layer.assert_called_once_with(10, 'tempfile')
filesystem.create_verification_metadata.assert_called_once_with(
'/dev/root-device'
)
@patch('kiwi.builder.disk.DeviceProvider')
@patch('kiwi.builder.disk.FileSystem.new')
@patch('kiwi.builder.disk.FileSystemSquashFs')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
@patch('os.path.exists')
@patch('os.path.getsize')
@patch('kiwi.builder.disk.Temporary.new_file')
@patch('random.randrange')
@patch('kiwi.builder.disk.BlockID')
def test_create_disk_standard_root_is_overlay(
self, mock_BlockID, mock_rand, mock_temp,
mock_getsize, mock_exists, mock_grub_dir, mock_command,
mock_squashfs, mock_fs, mock_DeviceProvider
):
block_operation = Mock()
block_operation.get_blkid.return_value = 'partuuid'
block_operation.get_filesystem.return_value = 'ext3'
mock_BlockID.return_value = block_operation
mock_rand.return_value = 15
self.disk_builder.root_filesystem_is_overlay = True
self.disk_builder.root_filesystem_has_write_partition = False
self.disk_builder.root_filesystem_verity_blocks = 10
self.disk_builder.root_filesystem_embed_verity_metadata = True
self.disk_builder.volume_manager_name = None
squashfs = Mock()
mock_squashfs.return_value = squashfs
mock_getsize.return_value = 1048576
tempfile = Mock()
tempfile.name = 'kiwi-tempname'
mock_temp.return_value = tempfile
mock_exists.return_value = True
self.disk_builder.initrd_system = 'dracut'
self.disk.public_partition_id_map = self.id_map
self.disk.public_partition_id_map['kiwi_ROPart'] = 1
m_open = mock_open()
with patch('builtins.open', m_open, create=True):
self.disk_builder.create_disk()
assert mock_squashfs.call_args_list == [
call(
custom_args={'compression': None},
device_provider=mock_DeviceProvider.return_value,
root_dir='root_dir'
), call(
custom_args={'compression': None},
device_provider=mock_DeviceProvider.return_value,
root_dir='root_dir'
)
]
assert squashfs.create_on_file.call_args_list == [
call(exclude=['var/cache/kiwi'], filename='kiwi-tempname'),
call(exclude=[
'.profile', '.kconfig', 'run/*', 'tmp/*',
'.buildenv', 'var/cache/kiwi',
'boot/*', 'boot/.*', 'boot/efi/*', 'boot/efi/.*', 'image/*'
], filename='kiwi-tempname')
]
squashfs.create_verity_layer.assert_called_once_with(10)
squashfs.create_verification_metadata.assert_called_once_with(
'/dev/readonly-root-device'
)
self.disk.create_root_readonly_partition.assert_called_once_with(11)
assert mock_command.call_args_list[2] == call(
['blockdev', '--getsize64', '/dev/readonly-root-device']
)
assert mock_command.call_args_list[3] == call(
['dd', 'if=kiwi-tempname', 'of=/dev/readonly-root-device']
)
assert m_open.return_value.write.call_args_list == [
# config.partids
call('kiwi_BootPart="1"\n'),
call('kiwi_RootPart="1"\n'),
# mbrid
call('0x0f0f0f0f\n'),
# config.bootoptions
call('boot_cmdline\n'),
# some-loop
call(b'\x0f\x0f\x0f\x0f')
]
assert self.boot_image_task.include_module.call_args_list == [
call('kiwi-overlay'), call('kiwi-repart')
]
self.boot_image_task.omit_module.assert_called_once_with('multipath')
self.boot_image_task.write_system_config_file.assert_called_once_with(
config={'modules': ['kiwi-overlay']}
)
@patch('kiwi.builder.disk.FileSystem.new')
@patch('kiwi.builder.disk.Command.run')
def test_create_disk_standard_root_no_hypervisor_found(
self, mock_command, mock_fs
):
self.kernel.get_xen_hypervisor.return_value = False
self.disk_builder.volume_manager_name = None
self.disk_builder.xen_server = True
with patch('builtins.open'):
with raises(KiwiDiskBootImageError):
self.disk_builder.create_disk()
@patch('kiwi.builder.disk.FileSystem.new')
@patch('kiwi.builder.disk.Command.run')
def test_create_disk_standard_root_xen_server_boot(
self, mock_command, mock_fs
):
filesystem = Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.xen_server = True
self.firmware.efi_mode = Mock(
return_value=False
)
with patch('builtins.open'):
self.disk_builder.create_disk()
self.kernel.copy_xen_hypervisor.assert_called_once_with(
'root_dir', '/boot/xen.gz'
)
@patch('kiwi.builder.disk.FileSystem.new')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_standard_root_s390_boot(
self, mock_grub_dir, mock_command, mock_fs
):
self.disk_builder.arch = 's390x'
filesystem = Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.firmware.efi_mode = Mock(
return_value=False
)
self.disk_builder.bootloader = 'grub2_s390x_emu'
with patch('builtins.open'):
self.disk_builder.create_disk()
self.bootloader_config.write.assert_called_once_with()
@patch('kiwi.builder.disk.FileSystem.new')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_standard_root_secure_boot(
self, mock_grub_dir, mock_command, mock_fs
):
filesystem = Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.firmware.efi_mode = Mock(
return_value='uefi'
)
with patch('builtins.open'):
self.disk_builder.create_disk()
bootloader = self.bootloader_config
bootloader.setup_disk_boot_images.assert_called_once_with('0815')
@patch('kiwi.builder.disk.FileSystem.new')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_mdraid_root(
self, mock_grub_dir, mock_command, mock_fs
):
filesystem = Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.mdraid = 'mirroring'
self.disk.public_partition_id_map = self.id_map
with patch('builtins.open'):
self.disk_builder.create_disk()
self.disk.create_root_raid_partition.assert_called_once_with(
'all_free'
)
self.raid_root.create_degraded_raid.assert_called_once_with(
raid_level='mirroring'
)
self.raid_root.create_raid_config.assert_called_once_with(
'boot_dir/etc/mdadm.conf'
)
assert self.disk.public_partition_id_map == {
'kiwi_RaidPart': 1, 'kiwi_RootPart': 1, 'kiwi_BootPart': 1,
'kiwi_RaidDev': '/dev/md0'
}
@patch('kiwi.builder.disk.FileSystem.new')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_luks_root(
self, mock_grub_dir, mock_command, mock_fs
):
filesystem = Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.luks = 'passphrase'
self.disk_setup.need_boot_partition.return_value = False
self.disk_builder.root_filesystem_is_overlay = True
self.disk_builder.root_filesystem_has_write_partition = False
self.disk_builder.boot_is_crypto = True
self.disk.public_partition_id_map = self.id_map
self.disk.public_partition_id_map['kiwi_ROPart'] = 1
with patch('builtins.open'):
self.disk_builder.create_disk()
self.luks_root.create_crypto_luks.assert_called_once_with(
passphrase='passphrase', os=None,
options=[], keyfile='root_dir/.root.keyfile'
)
self.luks_root.create_crypttab.assert_called_once_with(
'root_dir/etc/crypttab'
)
assert self.boot_image_task.include_file.call_args_list == [
call('/.root.keyfile'),
call('/config.partids'),
call('/etc/crypttab')
]
self.boot_image_task.write_system_config_file.assert_called_once_with(
config={'install_items': ['/.root.keyfile']},
config_file='root_dir/etc/dracut.conf.d/99-luks-boot.conf'
)
@patch('kiwi.builder.disk.FileSystem.new')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
@patch('os.path.exists')
def test_create_disk_uses_custom_partitions(
self, mock_exists, mock_grub_dir, mock_command, mock_fs
):
mock_exists.return_value = True
self.disk_builder.custom_partitions = {
'var': ptable_entry_type(
mbsize=100,
partition_name='p.lxvar',
partition_type='t.linux',
mountpoint='/var',
filesystem='ext3'
)
}
self.disk_builder.volume_manager_name = None
filesystem = Mock()
mock_fs.return_value = filesystem
with patch('builtins.open'):
self.disk_builder.create_disk()
self.disk.persistency_type = 'by-uuid'
self.disk.create_custom_partitions.assert_called_once_with(
self.disk_builder.custom_partitions
)
assert [
call('UUID=blkid_result /var blkid_result_fs defaults 0 0')
] in self.disk_builder.fstab.add_entry.call_args_list
self.disk_builder.persistency_type = 'by-partuuid'
with patch('builtins.open'):
self.disk_builder.create_disk()
assert [
call('PARTUUID=blkid_result /var blkid_result_fs defaults 0 0')
] in self.disk_builder.fstab.add_entry.call_args_list
self.disk_builder.persistency_type = 'by-label'
with patch('builtins.open'):
self.disk_builder.create_disk()
assert [
call('LABEL=blkid_result /var blkid_result_fs defaults 0 0')
] in self.disk_builder.fstab.add_entry.call_args_list
@patch('kiwi.builder.disk.FileSystem.new')
@patch('kiwi.builder.disk.VolumeManager.new')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
@patch('kiwi.builder.disk.ImageSystem')
@patch('os.path.exists')
def test_create_disk_volume_managed_root(
self, mock_exists, mock_ImageSystem, mock_grub_dir, mock_command,
mock_volume_manager, mock_fs
):
mock_exists.return_value = True
volume_manager = Mock()
volume_manager.get_device = Mock(
return_value={
'root': MappedDevice('/dev/systemVG/LVRoot', Mock()),
'swap': MappedDevice('/dev/systemVG/LVSwap', Mock())
}
)
volume_manager.get_fstab = Mock(
return_value=['fstab_volume_entries']
)
mock_volume_manager.return_value = volume_manager
filesystem = Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = 'lvm'
with patch('builtins.open'):
self.disk_builder.create_disk()
self.disk.create_root_lvm_partition.assert_called_once_with('all_free')
volume_manager.setup.assert_called_once_with('systemVG')
volume_manager.create_volumes.assert_called_once_with('btrfs')
volume_manager.mount_volumes.call_args_list[0].assert_called_once_with()
assert volume_manager.get_fstab.call_args_list == [
call(None, 'btrfs'),
call(None, 'btrfs')
]
volume_manager.sync_data.assert_called_once_with(
[
'image', '.profile', '.kconfig', 'run/*', 'tmp/*',
'.buildenv', 'var/cache/kiwi',
'boot/*', 'boot/.*', 'boot/efi/*', 'boot/efi/.*'
]
)
volume_manager.umount_volumes.call_args_list[0].assert_called_once_with(
)
self.setup.create_fstab.assert_called_once_with(
self.disk_builder.fstab
)
self.boot_image_task.setup.create_fstab.assert_called_once_with(
self.disk_builder.fstab
)
@patch('kiwi.builder.disk.FileSystem.new')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_hybrid_gpt_requested(
self, mock_grub_dir, mock_command, mock_fs
):
filesystem = Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.install_media = False
self.disk_builder.hybrid_mbr = True
with patch('builtins.open'):
self.disk_builder.create_disk()
self.disk.create_hybrid_mbr.assert_called_once_with()
@patch('kiwi.builder.disk.FileSystem.new')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_force_mbr_requested(
self, mock_grub_dir, mock_command, mock_fs
):
filesystem = Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.install_media = False
self.disk_builder.force_mbr = True
with patch('builtins.open'):
self.disk_builder.create_disk()
self.disk.create_mbr.assert_called_once_with()
def test_create(self):
result = Mock()
create_disk = Mock(return_value=result)
create_install_media = Mock(return_value=result)
append_unpartitioned = Mock()
create_disk_format = Mock(return_value=result)
self.disk_builder.create_disk = create_disk
self.disk_builder.create_install_media = create_install_media
self.disk_builder.append_unpartitioned_space = append_unpartitioned
self.disk_builder.create_disk_format = create_disk_format
self.disk_builder.create()
create_disk.assert_called_once_with()
create_install_media.assert_called_once_with(result)
append_unpartitioned.assert_called_once_with()
create_disk_format.assert_called_once_with(result)
@patch('kiwi.builder.disk.FileSystem.new')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_spare_part_requested(
self, mock_grub_dir, mock_command, mock_fs
):
filesystem = Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.install_media = False
self.disk_builder.spare_part_mbsize = 42
self.disk_builder.spare_part_fs = 'ext4'
self.disk_builder.spare_part_mountpoint = '/var'
self.disk_builder.spare_part_is_last = False
with patch('builtins.open'):
self.disk_builder.create_disk()
self.disk.create_spare_partition.assert_called_once_with('42')
assert mock_fs.call_args_list[0] == call(
self.disk_builder.spare_part_fs,
self.device_map['spare'],
'root_dir/var/',
{'fs_attributes': None}
)
assert filesystem.sync_data.call_args_list.pop() == call(
[
'image', '.profile', '.kconfig', 'run/*', 'tmp/*',
'.buildenv', 'var/cache/kiwi', 'var/*', 'var/.*',
'boot/*', 'boot/.*', 'boot/efi/*', 'boot/efi/.*'
]
)
assert [
call('UUID=blkid_result / blkid_result_fs ro 0 0'),
call('UUID=blkid_result /boot blkid_result_fs defaults 0 0'),
call('UUID=blkid_result /boot/efi blkid_result_fs defaults 0 0'),
call('UUID=blkid_result /var blkid_result_fs defaults 0 0'),
call('UUID=blkid_result swap blkid_result_fs defaults 0 0'),
] in self.disk_builder.fstab.add_entry.call_args_list
self.disk.create_root_partition.reset_mock()
self.disk.create_spare_partition.reset_mock()
self.disk_builder.spare_part_is_last = True
self.disk_builder.disk_resize_requested = False
with patch('builtins.open'):
self.disk_builder.create_disk()
self.disk.create_spare_partition.assert_called_once_with(
'all_free'
)
@patch('kiwi.builder.disk.LoopDevice')
@patch('kiwi.builder.disk.Partitioner.new')
@patch('kiwi.builder.disk.DiskFormat.new')
def test_append_unpartitioned_space(
self, mock_diskformat, mock_partitioner, mock_loopdevice
):
loopdevice = Mock()
mock_loopdevice.return_value = loopdevice
partitioner = Mock()
mock_partitioner.return_value = partitioner
disk_format = Mock()
mock_diskformat.return_value = disk_format
self.disk_builder.unpartitioned_bytes = 1024
self.disk_builder.append_unpartitioned_space()
disk_format.resize_raw_disk.assert_called_once_with(
1024, append=True
)
loopdevice.create.assert_called_once_with(overwrite=False)
assert partitioner.resize_table.called
@patch('kiwi.builder.disk.FileSystem.new')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.DiskFormat.new')
def test_create_disk_format(self, mock_DiskFormat, mock_command, mock_fs):
disk_subformat = Mock()
mock_DiskFormat.return_value = disk_subformat
result_instance = Mock()
filesystem = Mock()
mock_fs.return_value = filesystem
self.disk_builder.install_media = False
self.disk_builder.image_format = 'vmdk'
with patch('builtins.open'):
self.disk_builder.create_disk_format(result_instance)
disk_subformat.create_image_format.assert_called_once_with()
def test_setup_warn_no_initrd_support(self):
self.boot_image_task.has_initrd_support = Mock(
return_value=False
)
with self._caplog.at_level(logging.WARNING):
DiskBuilder(self.xml_state, 'target_dir', 'root_dir')
def setup(self, mock_machine, mock_exists):
mock_machine.return_value = 'x86_64'
mock_exists.return_value = True
description = XMLDescription(
'../data/example_disk_config.xml'
)
self.device_map = {
'root': MappedDevice('/dev/root-device', mock.Mock()),
'readonly': MappedDevice('/dev/readonly-root-device', mock.Mock()),
'boot': MappedDevice('/dev/boot-device', mock.Mock()),
'prep': MappedDevice('/dev/prep-device', mock.Mock()),
'efi': MappedDevice('/dev/efi-device', mock.Mock())
}
self.id_map = {
'kiwi_RootPart': 1,
'kiwi_BootPart': 1
}
self.id_map_sorted = OrderedDict(
sorted(self.id_map.items())
)
self.block_operation = mock.Mock()
self.block_operation.get_blkid = mock.Mock(
return_value='blkid_result'
)
self.block_operation.get_filesystem = mock.Mock(
return_value='filesystem'
)
kiwi.builder.disk.BlockID = mock.Mock(
return_value=self.block_operation
)
self.loop_provider = mock.Mock()
kiwi.builder.disk.LoopDevice = mock.Mock(
return_value=self.loop_provider
)
self.disk = mock.Mock()
provider = mock.Mock()
provider.get_device = mock.Mock(
return_value='/dev/some-loop'
)
self.disk.storage_provider = provider
self.partitioner = mock.Mock()
self.partitioner.get_id = mock.Mock(
return_value=1
)
self.disk.partitioner = self.partitioner
self.disk.get_uuid = mock.Mock(
return_value='0815'
)
self.disk.get_public_partition_id_map = mock.Mock(
return_value=self.id_map_sorted
)
self.disk.get_device = mock.Mock(
return_value=self.device_map
)
kernel_info = mock.Mock()
kernel_info.version = '1.2.3'
self.kernel = mock.Mock()
self.kernel.get_kernel = mock.Mock(
return_value=kernel_info
)
self.kernel.get_xen_hypervisor = mock.Mock()
self.kernel.copy_kernel = mock.Mock()
self.kernel.copy_xen_hypervisor = mock.Mock()
kiwi.builder.disk.Kernel = mock.Mock(
return_value=self.kernel
)
self.disk.subformat = mock.Mock()
self.disk.subformat.get_target_name_for_format = mock.Mock(
return_value='some-target-format-name'
)
kiwi.builder.disk.DiskFormat = mock.Mock(
return_value=self.disk.subformat
)
kiwi.builder.disk.Disk = mock.Mock(
return_value=self.disk
)
self.disk_setup = mock.Mock()
self.disk_setup.get_efi_label = mock.Mock(
return_value='EFI'
)
self.disk_setup.get_root_label = mock.Mock(
return_value='ROOT'
)
self.disk_setup.get_boot_label = mock.Mock(
return_value='BOOT'
)
self.disk_setup.need_boot_partition = mock.Mock(
return_value=True
)
self.bootloader_install = mock.Mock()
kiwi.builder.disk.BootLoaderInstall = mock.MagicMock(
return_value=self.bootloader_install
)
self.bootloader_config = mock.Mock()
kiwi.builder.disk.BootLoaderConfig = mock.MagicMock(
return_value=self.bootloader_config
)
kiwi.builder.disk.DiskSetup = mock.MagicMock(
return_value=self.disk_setup
)
self.boot_image_task = mock.Mock()
self.boot_image_task.boot_root_directory = 'boot_dir'
self.boot_image_task.kernel_filename = 'kernel'
self.boot_image_task.initrd_filename = 'initrd'
self.boot_image_task.xen_hypervisor_filename = 'xen_hypervisor'
kiwi.builder.disk.BootImage = mock.Mock(
return_value=self.boot_image_task
)
self.firmware = mock.Mock()
self.firmware.efi_mode = mock.Mock(
return_value='efi'
)
kiwi.builder.disk.FirmWare = mock.Mock(
return_value=self.firmware
)
self.setup = mock.Mock()
kiwi.builder.disk.SystemSetup = mock.Mock(
return_value=self.setup
)
self.boot_image_kiwi = mock.Mock()
self.boot_image_kiwi.boot_root_directory = 'boot_dir_kiwi'
kiwi.builder.disk.BootImageKiwi = mock.Mock(
return_value=self.boot_image_kiwi
)
self.install_image = mock.Mock()
kiwi.builder.disk.InstallImageBuilder = mock.Mock(
return_value=self.install_image
)
self.raid_root = mock.Mock()
kiwi.builder.disk.RaidDevice = mock.Mock(
return_value=self.raid_root
)
self.luks_root = mock.Mock()
kiwi.builder.disk.LuksDevice = mock.Mock(
return_value=self.luks_root
)
self.disk_builder = DiskBuilder(
XMLState(description.load()), 'target_dir', 'root_dir'
)
self.disk_builder.root_filesystem_is_overlay = False
self.disk_builder.build_type_name = 'oem'
self.machine = mock.Mock()
self.machine.get_domain = mock.Mock(
return_value='dom0'
)
self.disk_builder.machine = self.machine
self.disk_builder.image_format = None
class TestDiskBuilder(object):
@patch('os.path.exists')
@patch('platform.machine')
def setup(self, mock_machine, mock_exists):
mock_machine.return_value = 'x86_64'
mock_exists.return_value = True
description = XMLDescription(
'../data/example_disk_config.xml'
)
self.device_map = {
'root': MappedDevice('/dev/root-device', mock.Mock()),
'readonly': MappedDevice('/dev/readonly-root-device', mock.Mock()),
'boot': MappedDevice('/dev/boot-device', mock.Mock()),
'prep': MappedDevice('/dev/prep-device', mock.Mock()),
'efi': MappedDevice('/dev/efi-device', mock.Mock())
}
self.id_map = {
'kiwi_RootPart': 1,
'kiwi_BootPart': 1
}
self.id_map_sorted = OrderedDict(
sorted(self.id_map.items())
)
self.block_operation = mock.Mock()
self.block_operation.get_blkid = mock.Mock(
return_value='blkid_result'
)
self.block_operation.get_filesystem = mock.Mock(
return_value='filesystem'
)
kiwi.builder.disk.BlockID = mock.Mock(
return_value=self.block_operation
)
self.loop_provider = mock.Mock()
kiwi.builder.disk.LoopDevice = mock.Mock(
return_value=self.loop_provider
)
self.disk = mock.Mock()
provider = mock.Mock()
provider.get_device = mock.Mock(
return_value='/dev/some-loop'
)
self.disk.storage_provider = provider
self.partitioner = mock.Mock()
self.partitioner.get_id = mock.Mock(
return_value=1
)
self.disk.partitioner = self.partitioner
self.disk.get_uuid = mock.Mock(
return_value='0815'
)
self.disk.get_public_partition_id_map = mock.Mock(
return_value=self.id_map_sorted
)
self.disk.get_device = mock.Mock(
return_value=self.device_map
)
kernel_info = mock.Mock()
kernel_info.version = '1.2.3'
self.kernel = mock.Mock()
self.kernel.get_kernel = mock.Mock(
return_value=kernel_info
)
self.kernel.get_xen_hypervisor = mock.Mock()
self.kernel.copy_kernel = mock.Mock()
self.kernel.copy_xen_hypervisor = mock.Mock()
kiwi.builder.disk.Kernel = mock.Mock(
return_value=self.kernel
)
self.disk.subformat = mock.Mock()
self.disk.subformat.get_target_name_for_format = mock.Mock(
return_value='some-target-format-name'
)
kiwi.builder.disk.DiskFormat = mock.Mock(
return_value=self.disk.subformat
)
kiwi.builder.disk.Disk = mock.Mock(
return_value=self.disk
)
self.disk_setup = mock.Mock()
self.disk_setup.get_efi_label = mock.Mock(
return_value='EFI'
)
self.disk_setup.get_root_label = mock.Mock(
return_value='ROOT'
)
self.disk_setup.get_boot_label = mock.Mock(
return_value='BOOT'
)
self.disk_setup.need_boot_partition = mock.Mock(
return_value=True
)
self.bootloader_install = mock.Mock()
kiwi.builder.disk.BootLoaderInstall = mock.MagicMock(
return_value=self.bootloader_install
)
self.bootloader_config = mock.Mock()
kiwi.builder.disk.BootLoaderConfig = mock.MagicMock(
return_value=self.bootloader_config
)
kiwi.builder.disk.DiskSetup = mock.MagicMock(
return_value=self.disk_setup
)
self.boot_image_task = mock.Mock()
self.boot_image_task.boot_root_directory = 'boot_dir'
self.boot_image_task.kernel_filename = 'kernel'
self.boot_image_task.initrd_filename = 'initrd'
self.boot_image_task.xen_hypervisor_filename = 'xen_hypervisor'
kiwi.builder.disk.BootImage = mock.Mock(
return_value=self.boot_image_task
)
self.firmware = mock.Mock()
self.firmware.efi_mode = mock.Mock(
return_value='efi'
)
kiwi.builder.disk.FirmWare = mock.Mock(
return_value=self.firmware
)
self.setup = mock.Mock()
kiwi.builder.disk.SystemSetup = mock.Mock(
return_value=self.setup
)
self.boot_image_kiwi = mock.Mock()
self.boot_image_kiwi.boot_root_directory = 'boot_dir_kiwi'
kiwi.builder.disk.BootImageKiwi = mock.Mock(
return_value=self.boot_image_kiwi
)
self.install_image = mock.Mock()
kiwi.builder.disk.InstallImageBuilder = mock.Mock(
return_value=self.install_image
)
self.raid_root = mock.Mock()
kiwi.builder.disk.RaidDevice = mock.Mock(
return_value=self.raid_root
)
self.luks_root = mock.Mock()
kiwi.builder.disk.LuksDevice = mock.Mock(
return_value=self.luks_root
)
self.disk_builder = DiskBuilder(
XMLState(description.load()), 'target_dir', 'root_dir'
)
self.disk_builder.root_filesystem_is_overlay = False
self.disk_builder.build_type_name = 'oem'
self.machine = mock.Mock()
self.machine.get_domain = mock.Mock(
return_value='dom0'
)
self.disk_builder.machine = self.machine
self.disk_builder.image_format = None
@patch('os.path.exists')
@patch('platform.machine')
def test_setup_ix86(self, mock_machine, mock_exists):
mock_machine.return_value = 'i686'
description = XMLDescription(
'../data/example_disk_config.xml'
)
disk_builder = DiskBuilder(
XMLState(description.load()), 'target_dir', 'root_dir'
)
assert disk_builder.arch == 'ix86'
@raises(KiwiInstallMediaError)
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
def test_create_invalid_type_for_install_media(
self, mock_cmd, mock_open, mock_fs
):
self.disk_builder.build_type_name = 'vmx'
self.disk_builder.create_disk()
@raises(KiwiVolumeManagerSetupError)
def test_create_disk_overlay_with_volume_setup_not_supported(self):
self.disk_builder.root_filesystem_is_overlay = True
self.disk_builder.volume_manager_name = 'lvm'
self.disk_builder.create_disk()
@patch_open
@patch('os.path.exists')
@patch('pickle.load')
@patch('kiwi.builder.disk.Path.wipe')
def test_create_install_media(
self, mock_wipe, mock_load, mock_path, mock_open
):
result_instance = mock.Mock()
mock_path.return_value = True
self.disk_builder.install_iso = True
self.disk_builder.install_pxe = True
self.disk_builder.create_install_media(result_instance)
self.install_image.create_install_iso.assert_called_once_with()
self.install_image.create_install_pxe_archive.assert_called_once_with()
mock_wipe.assert_called_once_with('target_dir/boot_image.pickledump')
@patch('os.path.exists')
@raises(KiwiInstallMediaError)
def test_create_install_media_no_boot_instance_found(self, mock_path):
result_instance = mock.Mock()
mock_path.return_value = False
self.disk_builder.install_iso = True
self.disk_builder.create_install_media(result_instance)
@patch('os.path.exists')
@patch('pickle.load')
@raises(KiwiInstallMediaError)
def test_create_install_media_pickle_load_error(self, mock_load, mock_path):
result_instance = mock.Mock()
mock_load.side_effect = Exception
mock_path.return_value = True
self.disk_builder.install_iso = True
self.disk_builder.create_install_media(result_instance)
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('random.randrange')
@patch('kiwi.builder.disk.Command.run')
@patch('os.path.exists')
def test_create_disk_standard_root_with_kiwi_initrd(
self, mock_path, mock_command, mock_rand, mock_open, mock_fs
):
mock_path.return_value = True
mock_rand.return_value = 15
context_manager_mock = mock.Mock()
mock_open.return_value = context_manager_mock
file_mock = mock.Mock()
enter_mock = mock.Mock()
exit_mock = mock.Mock()
enter_mock.return_value = file_mock
setattr(context_manager_mock, '__enter__', enter_mock)
setattr(context_manager_mock, '__exit__', exit_mock)
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.initrd_system = 'kiwi'
self.disk_builder.create_disk()
self.setup.create_recovery_archive.assert_called_once_with()
call = self.setup.export_modprobe_setup.call_args_list[0]
assert self.setup.export_modprobe_setup.call_args_list[0] == \
call('boot_dir')
self.setup.set_selinux_file_contexts.assert_called_once_with(
'/etc/selinux/targeted/contexts/files/file_contexts'
)
self.disk_setup.get_disksize_mbytes.assert_called_once_with()
self.loop_provider.create.assert_called_once_with()
self.disk.wipe.assert_called_once_with()
self.disk.create_efi_csm_partition.assert_called_once_with(
self.firmware.get_legacy_bios_partition_size()
)
self.disk.create_efi_partition.assert_called_once_with(
self.firmware.get_efi_partition_size()
)
self.disk.create_boot_partition.assert_called_once_with(
self.disk_setup.boot_partition_size()
)
self.disk.create_prep_partition.assert_called_once_with(
self.firmware.get_prep_partition_size()
)
self.disk.create_root_partition.assert_called_once_with(
'all_free'
)
self.disk.map_partitions.assert_called_once_with()
self.bootloader_config.setup_disk_boot_images.assert_called_once_with(
'0815'
)
self.bootloader_config.setup_disk_image_config.assert_called_once_with(
initrd='initrd.vmx', kernel='linux.vmx', uuid='0815'
)
self.setup.call_edit_boot_config_script.assert_called_once_with(
'btrfs', 1
)
self.bootloader_install.install.assert_called_once_with()
self.setup.call_edit_boot_install_script.assert_called_once_with(
'target_dir/LimeJeOS-openSUSE-13.2.x86_64-1.13.2.raw',
'/dev/boot-device'
)
self.boot_image_task.prepare.assert_called_once_with()
call = filesystem.create_on_device.call_args_list[0]
assert filesystem.create_on_device.call_args_list[0] == \
call(label='EFI')
call = filesystem.create_on_device.call_args_list[1]
assert filesystem.create_on_device.call_args_list[1] == \
call(label='BOOT')
call = filesystem.create_on_device.call_args_list[2]
assert filesystem.create_on_device.call_args_list[2] == \
call(label='ROOT')
call = filesystem.sync_data.call_args_list[0]
assert filesystem.sync_data.call_args_list[0] == \
call()
call = filesystem.sync_data.call_args_list[1]
assert filesystem.sync_data.call_args_list[1] == \
call(['efi/*'])
call = filesystem.sync_data.call_args_list[2]
assert filesystem.sync_data.call_args_list[2] == \
call([
'image', '.profile', '.kconfig', 'var/cache/kiwi',
'boot/*', 'boot/.*', 'boot/efi/*', 'boot/efi/.*'
])
assert mock_open.call_args_list[0:3] == [
call('boot_dir/config.partids', 'w'),
call('root_dir/boot/mbrid', 'w'),
call('/dev/some-loop', 'wb')
]
assert file_mock.write.call_args_list == [
call('kiwi_BootPart="1"\n'),
call('kiwi_RootPart="1"\n'),
call('0x0f0f0f0f\n'),
call(bytes(b'\x0f\x0f\x0f\x0f')),
]
assert mock_command.call_args_list == [
call(['cp', 'root_dir/recovery.partition.size', 'boot_dir']),
call(['mv', 'initrd', 'root_dir/boot/initrd.vmx']),
]
self.setup.export_rpm_package_list.assert_called_once_with(
'target_dir'
)
self.setup.export_rpm_package_verification.assert_called_once_with(
'target_dir'
)
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('random.randrange')
@patch('kiwi.builder.disk.Command.run')
@patch('os.path.exists')
def test_create_disk_standard_root_with_dracut_initrd(
self, mock_path, mock_command, mock_rand, mock_open, mock_fs
):
mock_path.return_value = True
mock_rand.return_value = 15
context_manager_mock = mock.Mock()
mock_open.return_value = context_manager_mock
file_mock = mock.Mock()
enter_mock = mock.Mock()
exit_mock = mock.Mock()
enter_mock.return_value = file_mock
setattr(context_manager_mock, '__enter__', enter_mock)
setattr(context_manager_mock, '__exit__', exit_mock)
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.initrd_system = 'dracut'
self.disk_builder.create_disk()
self.setup.create_recovery_archive.assert_called_once_with()
call = self.setup.export_modprobe_setup.call_args_list[0]
assert self.setup.export_modprobe_setup.call_args_list[0] == \
call('boot_dir')
call = self.setup.export_modprobe_setup.call_args_list[1]
assert self.setup.export_modprobe_setup.call_args_list[1] == \
call('boot_dir_kiwi')
self.setup.set_selinux_file_contexts.assert_called_once_with(
'/etc/selinux/targeted/contexts/files/file_contexts'
)
self.disk_setup.get_disksize_mbytes.assert_called_once_with()
self.loop_provider.create.assert_called_once_with()
self.disk.wipe.assert_called_once_with()
self.disk.create_efi_csm_partition.assert_called_once_with(
self.firmware.get_legacy_bios_partition_size()
)
self.disk.create_efi_partition.assert_called_once_with(
self.firmware.get_efi_partition_size()
)
self.disk.create_boot_partition.assert_called_once_with(
self.disk_setup.boot_partition_size()
)
self.disk.create_prep_partition.assert_called_once_with(
self.firmware.get_prep_partition_size()
)
self.disk.create_root_partition.assert_called_once_with(
'all_free'
)
self.disk.map_partitions.assert_called_once_with()
self.bootloader_config.setup_disk_boot_images.assert_called_once_with(
'0815'
)
self.bootloader_config.setup_disk_image_config.assert_called_once_with(
initrd='initrd-1.2.3', kernel='vmlinuz-1.2.3', uuid='0815'
)
self.setup.call_edit_boot_config_script.assert_called_once_with(
'btrfs', 1
)
self.bootloader_install.install.assert_called_once_with()
self.setup.call_edit_boot_install_script.assert_called_once_with(
'target_dir/LimeJeOS-openSUSE-13.2.x86_64-1.13.2.raw',
'/dev/boot-device'
)
self.boot_image_kiwi.prepare.assert_called_once_with()
self.boot_image_task.prepare.assert_called_once_with()
call = filesystem.create_on_device.call_args_list[0]
assert filesystem.create_on_device.call_args_list[0] == \
call(label='EFI')
call = filesystem.create_on_device.call_args_list[1]
assert filesystem.create_on_device.call_args_list[1] == \
call(label='BOOT')
call = filesystem.create_on_device.call_args_list[2]
assert filesystem.create_on_device.call_args_list[2] == \
call(label='ROOT')
call = filesystem.sync_data.call_args_list[0]
assert filesystem.sync_data.call_args_list[0] == \
call()
call = filesystem.sync_data.call_args_list[1]
assert filesystem.sync_data.call_args_list[1] == \
call(['efi/*'])
call = filesystem.sync_data.call_args_list[2]
assert filesystem.sync_data.call_args_list[2] == \
call([
'image', '.profile', '.kconfig', 'var/cache/kiwi',
'boot/*', 'boot/.*', 'boot/efi/*', 'boot/efi/.*'
])
assert mock_open.call_args_list == [
call('root_dir/boot/mbrid', 'w'),
call('/dev/some-loop', 'wb'),
call('boot_dir_kiwi/config.partids', 'w')
]
assert file_mock.write.call_args_list == [
call('0x0f0f0f0f\n'),
call(bytes(b'\x0f\x0f\x0f\x0f')),
call('kiwi_BootPart="1"\n'),
call('kiwi_RootPart="1"\n')
]
assert mock_command.call_args_list == [
call(['cp', 'root_dir/recovery.partition.size', 'boot_dir']),
call(['mv', 'initrd', 'root_dir/boot/initrd-1.2.3']),
call(['cp', 'root_dir/recovery.partition.size', 'boot_dir_kiwi'])
]
self.setup.export_rpm_package_list.assert_called_once_with(
'target_dir'
)
self.setup.export_rpm_package_verification.assert_called_once_with(
'target_dir'
)
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
def test_create_disk_standard_root_dracut_initrd_system(
self, mock_command, mock_open, mock_fs
):
self.disk_builder.initrd_system = 'dracut'
kernel = mock.Mock()
kernel.version = '1.2.3'
self.kernel.get_kernel.return_value = kernel
self.disk_builder.create_disk()
self.bootloader_config.setup_disk_image_config.assert_called_once_with(
uuid='0815', initrd='initrd-1.2.3', kernel='vmlinuz-1.2.3'
)
@patch('kiwi.builder.disk.FileSystem')
@patch('kiwi.builder.disk.FileSystemSquashFs')
@patch_open
@patch('kiwi.builder.disk.Command.run')
@patch('os.path.exists')
@patch('os.path.getsize')
@patch('kiwi.builder.disk.NamedTemporaryFile')
def test_create_disk_standard_root_is_overlay(
self, mock_temp, mock_getsize, mock_exists, mock_command,
mock_open, mock_squashfs, mock_fs
):
self.disk_builder.root_filesystem_is_overlay = True
squashfs = mock.Mock()
mock_squashfs.return_value = squashfs
mock_getsize.return_value = 1048576
tempfile = mock.Mock()
tempfile.name = 'tempname'
mock_temp.return_value = tempfile
mock_exists.return_value = True
self.disk_builder.create_disk()
assert mock_squashfs.call_args_list == [
call(device_provider=None, root_dir='root_dir'),
call(device_provider=None, root_dir='root_dir')
]
assert squashfs.create_on_file.call_args_list == [
call(exclude=['var/cache/kiwi'], filename='tempname'),
call(exclude=[
'image', '.profile', '.kconfig', 'var/cache/kiwi',
'boot/*', 'boot/.*', 'boot/efi/*', 'boot/efi/.*'
], filename='tempname')
]
self.disk.create_root_readonly_partition.assert_called_once_with(51)
assert mock_command.call_args_list.pop() == call(
['dd', 'if=tempname', 'of=/dev/readonly-root-device']
)
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
def test_create_disk_standard_root_dracut_initrd_system_on_arm(
self, mock_command, mock_open, mock_fs
):
self.disk_builder.initrd_system = 'dracut'
self.disk_builder.arch = 'aarch64'
kernel = mock.Mock()
kernel.version = '1.2.3'
self.kernel.get_kernel.return_value = kernel
self.disk_builder.create_disk()
self.bootloader_config.setup_disk_image_config.assert_called_once_with(
uuid='0815', initrd='initrd-1.2.3', kernel='zImage-1.2.3'
)
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
@raises(KiwiDiskBootImageError)
def test_create_disk_standard_root_no_kernel_found(
self, mock_command, mock_open, mock_fs
):
self.kernel.get_kernel.return_value = False
self.disk_builder.create_disk()
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
@raises(KiwiDiskBootImageError)
def test_create_disk_standard_root_no_hypervisor_found(
self, mock_command, mock_open, mock_fs
):
self.kernel.get_xen_hypervisor.return_value = False
self.disk_builder.create_disk()
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
def test_create_disk_standard_root_s390_boot(
self, mock_command, mock_open, mock_fs
):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.firmware.efi_mode = mock.Mock(
return_value=False
)
self.disk_builder.bootloader = 'grub2_s390x_emu'
self.disk_builder.create_disk()
assert mock_fs.call_args_list[1] == call(
'ext2', self.device_map['boot'], 'root_dir/boot/zipl/'
)
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
def test_create_disk_standard_root_secure_boot(
self, mock_command, mock_open, mock_fs
):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.firmware.efi_mode = mock.Mock(
return_value='uefi'
)
self.disk_builder.create_disk()
bootloader = self.bootloader_config
bootloader.setup_disk_boot_images.assert_called_once_with('0815')
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
def test_create_disk_mdraid_root(self, mock_command, mock_open, mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.mdraid = 'mirroring'
self.disk_builder.create_disk()
self.disk.create_root_raid_partition.assert_called_once_with(
'all_free'
)
self.raid_root.create_degraded_raid.assert_called_once_with(
raid_level='mirroring'
)
self.raid_root.create_raid_config.assert_called_once_with(
'boot_dir/etc/mdadm.conf'
)
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
def test_create_disk_luks_root(self, mock_command, mock_open, mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.luks = 'passphrase'
self.disk_builder.create_disk()
self.luks_root.create_crypto_luks.assert_called_once_with(
passphrase='passphrase', os=None
)
self.luks_root.create_crypttab.assert_called_once_with(
'root_dir/etc/crypttab'
)
@patch('kiwi.builder.disk.FileSystem')
@patch('kiwi.builder.disk.VolumeManager')
@patch_open
@patch('kiwi.builder.disk.Command.run')
@patch('os.path.exists')
def test_create_disk_volume_managed_root(
self, mock_exists, mock_command, mock_open, mock_volume_manager, mock_fs
):
mock_exists.return_value = True
volume_manager = mock.Mock()
volume_manager.get_device = mock.Mock(
return_value={
'root': MappedDevice('/dev/systemVG/LVRoot', mock.Mock())
}
)
volume_manager.get_fstab = mock.Mock(
return_value=['fstab_volume_entries']
)
mock_volume_manager.return_value = volume_manager
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = 'lvm'
self.disk_builder.create_disk()
self.disk.create_root_lvm_partition.assert_called_once_with(
'all_free'
)
volume_manager.setup.assert_called_once_with('systemVG')
volume_manager.create_volumes.assert_called_once_with('btrfs')
volume_manager.mount_volumes.call_args_list[0].assert_called_once_with()
volume_manager.get_fstab.assert_called_once_with(None, 'btrfs')
volume_manager.sync_data.assert_called_once_with([
'image', '.profile', '.kconfig', 'var/cache/kiwi',
'boot/*', 'boot/.*', 'boot/efi/*', 'boot/efi/.*'
])
volume_manager.umount_volumes.call_args_list[0].assert_called_once_with()
self.setup.create_fstab.assert_called_once_with(
[
'fstab_volume_entries',
'UUID=blkid_result / filesystem ro 0 0',
'UUID=blkid_result /boot filesystem defaults 0 0',
'UUID=blkid_result /boot/efi filesystem defaults 0 0'
]
)
self.boot_image_task.setup.create_fstab.assert_called_once_with(
[
'fstab_volume_entries',
'UUID=blkid_result / filesystem ro 0 0',
'UUID=blkid_result /boot filesystem defaults 0 0',
'UUID=blkid_result /boot/efi filesystem defaults 0 0'
]
)
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
def test_create_disk_hybrid_gpt_requested(
self, mock_command, mock_open, mock_fs
):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.install_media = False
self.disk_builder.hybrid_mbr = True
self.disk_builder.create_disk()
self.disk.create_hybrid_mbr.assert_called_once_with()
@patch('kiwi.builder.disk.DiskBuilder')
def test_create(
self, mock_builder
):
result = mock.Mock()
builder = mock.Mock()
builder.create_disk.return_value = result
builder.create_install_media.return_value = result
mock_builder.return_value = builder
self.disk_builder.create()
builder.create_disk.assert_called_once_with()
builder.create_install_media.assert_called_once_with(result)
builder.create_disk_format.assert_called_once_with(result)
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
def test_create_disk_vboot_firmware_requested(
self, mock_command, mock_open, mock_fs
):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.install_media = False
self.disk_builder.firmware.vboot_mode.return_value = True
self.disk_builder.firmware.get_vboot_partition_size.return_value = 42
self.disk_builder.create_disk()
self.disk.create_vboot_partition.assert_called_once_with(42)
@patch('kiwi.builder.disk.FileSystem')
@patch_open
@patch('kiwi.builder.disk.Command.run')
def test_create_disk_format(self, mock_command, mock_open, mock_fs):
result_instance = mock.Mock()
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.install_media = False
self.disk_builder.image_format = 'vmdk'
self.disk_builder.create_disk_format(result_instance)
self.disk.subformat.create_image_format.assert_called_once_with()
def setup(self, mock_machine, mock_exists):
mock_machine.return_value = 'x86_64'
def side_effect(filename):
if filename.endswith('.config/kiwi/config.yml'):
return False
else:
return True
mock_exists.side_effect = side_effect
description = XMLDescription(
'../data/example_disk_config.xml'
)
self.context_manager_mock = mock.Mock()
self.file_mock = mock.Mock()
self.enter_mock = mock.Mock()
self.exit_mock = mock.Mock()
self.enter_mock.return_value = self.file_mock
setattr(self.context_manager_mock, '__enter__', self.enter_mock)
setattr(self.context_manager_mock, '__exit__', self.exit_mock)
self.device_map = {
'root': MappedDevice('/dev/root-device', mock.Mock()),
'readonly': MappedDevice('/dev/readonly-root-device', mock.Mock()),
'boot': MappedDevice('/dev/boot-device', mock.Mock()),
'prep': MappedDevice('/dev/prep-device', mock.Mock()),
'efi': MappedDevice('/dev/efi-device', mock.Mock())
}
self.id_map = {
'kiwi_RootPart': 1,
'kiwi_BootPart': 1
}
self.id_map_sorted = OrderedDict(
sorted(self.id_map.items())
)
self.boot_names_type = namedtuple(
'boot_names_type', ['kernel_name', 'initrd_name']
)
self.block_operation = mock.Mock()
self.block_operation.get_blkid = mock.Mock(
return_value='blkid_result'
)
self.block_operation.get_filesystem = mock.Mock(
return_value='filesystem'
)
kiwi.builder.disk.BlockID = mock.Mock(
return_value=self.block_operation
)
self.loop_provider = mock.Mock()
kiwi.builder.disk.LoopDevice = mock.Mock(
return_value=self.loop_provider
)
self.disk = mock.Mock()
provider = mock.Mock()
provider.get_device = mock.Mock(
return_value='/dev/some-loop'
)
self.disk.storage_provider = provider
self.partitioner = mock.Mock()
self.partitioner.get_id = mock.Mock(
return_value=1
)
self.disk.partitioner = self.partitioner
self.disk.get_uuid = mock.Mock(
return_value='0815'
)
self.disk.get_public_partition_id_map = mock.Mock(
return_value=self.id_map_sorted
)
self.disk.get_device = mock.Mock(
return_value=self.device_map
)
kernel_info = mock.Mock()
kernel_info.version = '1.2.3'
kernel_info.name = 'vmlinuz-1.2.3-default'
self.kernel = mock.Mock()
self.kernel.get_kernel = mock.Mock(
return_value=kernel_info
)
self.kernel.get_xen_hypervisor = mock.Mock()
self.kernel.copy_kernel = mock.Mock()
self.kernel.copy_xen_hypervisor = mock.Mock()
kiwi.builder.disk.Kernel = mock.Mock(
return_value=self.kernel
)
self.disk.subformat = mock.Mock()
self.disk.subformat.get_target_file_path_for_format = mock.Mock(
return_value='some-target-format-name'
)
kiwi.builder.disk.DiskFormat = mock.Mock(
return_value=self.disk.subformat
)
kiwi.builder.disk.Disk = mock.Mock(
return_value=self.disk
)
self.disk_setup = mock.Mock()
self.disk_setup.get_efi_label = mock.Mock(
return_value='EFI'
)
self.disk_setup.get_root_label = mock.Mock(
return_value='ROOT'
)
self.disk_setup.get_boot_label = mock.Mock(
return_value='BOOT'
)
self.disk_setup.need_boot_partition = mock.Mock(
return_value=True
)
self.bootloader_install = mock.Mock()
kiwi.builder.disk.BootLoaderInstall = mock.MagicMock(
return_value=self.bootloader_install
)
self.bootloader_config = mock.Mock()
self.bootloader_config.get_boot_cmdline = mock.Mock(
return_value='boot_cmdline'
)
kiwi.builder.disk.BootLoaderConfig = mock.MagicMock(
return_value=self.bootloader_config
)
kiwi.builder.disk.DiskSetup = mock.MagicMock(
return_value=self.disk_setup
)
self.boot_image_task = mock.Mock()
self.boot_image_task.boot_root_directory = 'boot_dir'
self.boot_image_task.kernel_filename = 'kernel'
self.boot_image_task.initrd_filename = 'initrd'
self.boot_image_task.xen_hypervisor_filename = 'xen_hypervisor'
self.boot_image_task.get_boot_names.return_value = self.boot_names_type(
kernel_name='linux.vmx',
initrd_name='initrd.vmx'
)
kiwi.builder.disk.BootImage = mock.Mock(
return_value=self.boot_image_task
)
self.firmware = mock.Mock()
self.firmware.efi_mode = mock.Mock(
return_value='efi'
)
kiwi.builder.disk.FirmWare = mock.Mock(
return_value=self.firmware
)
self.setup = mock.Mock()
kiwi.builder.disk.SystemSetup = mock.Mock(
return_value=self.setup
)
self.install_image = mock.Mock()
kiwi.builder.disk.InstallImageBuilder = mock.Mock(
return_value=self.install_image
)
self.raid_root = mock.Mock()
self.raid_root.get_device.return_value = MappedDevice(
'/dev/md0', mock.Mock()
)
kiwi.builder.disk.RaidDevice = mock.Mock(
return_value=self.raid_root
)
self.luks_root = mock.Mock()
kiwi.builder.disk.LuksDevice = mock.Mock(
return_value=self.luks_root
)
self.disk_builder = DiskBuilder(
XMLState(description.load()), 'target_dir', 'root_dir',
custom_args={'signing_keys': ['key_file_a', 'key_file_b']}
)
self.disk_builder.root_filesystem_is_overlay = False
self.disk_builder.build_type_name = 'oem'
self.disk_builder.image_format = None
class TestDiskBuilder(object):
@patch('os.path.exists')
@patch('platform.machine')
def setup(self, mock_machine, mock_exists):
mock_machine.return_value = 'x86_64'
mock_exists.return_value = True
description = XMLDescription(
'../data/example_disk_config.xml'
)
self.device_map = {
'root': MappedDevice('/dev/root-device', mock.Mock()),
'boot': MappedDevice('/dev/boot-device', mock.Mock()),
'prep': MappedDevice('/dev/prep-device', mock.Mock()),
'efi': MappedDevice('/dev/efi-device', mock.Mock())
}
self.id_map = {
'kiwi_RootPart': 1,
'kiwi_BootPart': 1
}
self.id_map_sorted = OrderedDict(
sorted(self.id_map.items())
)
self.loop_provider = mock.Mock()
kiwi.builder.disk.LoopDevice = mock.Mock(
return_value=self.loop_provider
)
self.disk = mock.Mock()
provider = mock.Mock()
provider.get_device = mock.Mock(
return_value='/dev/some-loop'
)
self.disk.storage_provider = provider
self.partitioner = mock.Mock()
self.partitioner.get_id = mock.Mock(
return_value=1
)
self.disk.partitioner = self.partitioner
self.disk.get_uuid = mock.Mock(
return_value='0815'
)
self.disk.get_public_partition_id_map = mock.Mock(
return_value=self.id_map_sorted
)
self.disk.get_device = mock.Mock(
return_value=self.device_map
)
self.kernel = mock.Mock()
self.kernel.get_kernel = mock.Mock()
self.kernel.get_xen_hypervisor = mock.Mock()
self.kernel.copy_kernel = mock.Mock()
self.kernel.copy_xen_hypervisor = mock.Mock()
kiwi.builder.disk.Kernel = mock.Mock(
return_value=self.kernel
)
self.disk.subformat = mock.Mock()
self.disk.subformat.get_target_name_for_format = mock.Mock(
return_value='some-target-format-name'
)
kiwi.builder.disk.DiskFormat = mock.Mock(
return_value=self.disk.subformat
)
kiwi.builder.disk.Disk = mock.Mock(
return_value=self.disk
)
self.disk_setup = mock.Mock()
self.disk_setup.get_efi_label = mock.Mock(
return_value='EFI'
)
self.disk_setup.get_root_label = mock.Mock(
return_value='ROOT'
)
self.disk_setup.get_boot_label = mock.Mock(
return_value='BOOT'
)
self.disk_setup.need_boot_partition = mock.Mock(
return_value=True
)
self.bootloader_install = mock.Mock()
kiwi.builder.disk.BootLoaderInstall = mock.MagicMock(
return_value=self.bootloader_install
)
self.bootloader_config = mock.Mock()
kiwi.builder.disk.BootLoaderConfig = mock.MagicMock(
return_value=self.bootloader_config
)
kiwi.builder.disk.DiskSetup = mock.MagicMock(
return_value=self.disk_setup
)
self.boot_image_task = mock.Mock()
self.boot_image_task.boot_root_directory = 'boot_dir'
self.boot_image_task.kernel_filename = 'kernel'
self.boot_image_task.initrd_filename = 'initrd'
self.boot_image_task.xen_hypervisor_filename = 'xen_hypervisor'
kiwi.builder.disk.BootImage = mock.Mock(
return_value=self.boot_image_task
)
self.firmware = mock.Mock()
self.firmware.efi_mode = mock.Mock(
return_value='efi'
)
kiwi.builder.disk.FirmWare = mock.Mock(
return_value=self.firmware
)
self.setup = mock.Mock()
kiwi.builder.disk.SystemSetup = mock.Mock(
return_value=self.setup
)
self.install_image = mock.Mock()
kiwi.builder.disk.InstallImageBuilder = mock.Mock(
return_value=self.install_image
)
self.raid_root = mock.Mock()
kiwi.builder.disk.RaidDevice = mock.Mock(
return_value=self.raid_root
)
self.luks_root = mock.Mock()
kiwi.builder.disk.LuksDevice = mock.Mock(
return_value=self.luks_root
)
self.disk_builder = DiskBuilder(
XMLState(description.load()), 'target_dir', 'root_dir'
)
self.disk_builder.build_type_name = 'oem'
self.machine = mock.Mock()
self.machine.get_domain = mock.Mock(
return_value='dom0'
)
self.disk_builder.machine = self.machine
self.disk_builder.image_format = None
@patch('os.path.exists')
@patch('platform.machine')
def test_setup_ix86(self, mock_machine, mock_exists):
mock_machine.return_value = 'i686'
description = XMLDescription(
'../data/example_disk_config.xml'
)
disk_builder = DiskBuilder(
XMLState(description.load()), 'target_dir', 'root_dir'
)
assert disk_builder.arch == 'ix86'
@raises(KiwiInstallMediaError)
def test_create_invalid_type_for_install_media(self):
self.disk_builder.build_type_name = 'vmx'
self.disk_builder.create()
@patch('kiwi.builder.disk.FileSystem')
@patch('builtins.open')
@patch('random.randrange')
@patch('kiwi.builder.disk.Command.run')
@patch('os.path.exists')
def test_create_standard_root(
self, mock_path, mock_command, mock_rand, mock_open, mock_fs
):
mock_path.return_value = True
mock_rand.return_value = 15
context_manager_mock = mock.Mock()
mock_open.return_value = context_manager_mock
file_mock = mock.Mock()
enter_mock = mock.Mock()
exit_mock = mock.Mock()
enter_mock.return_value = file_mock
setattr(context_manager_mock, '__enter__', enter_mock)
setattr(context_manager_mock, '__exit__', exit_mock)
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.install_iso = True
self.disk_builder.install_pxe = True
self.disk_builder.create()
self.setup.create_recovery_archive.assert_called_once_with()
self.setup.export_modprobe_setup.assert_called_once_with(
'boot_dir'
)
self.disk_setup.get_disksize_mbytes.assert_called_once_with()
self.loop_provider.create.assert_called_once_with()
self.disk.wipe.assert_called_once_with()
self.disk.create_efi_csm_partition.assert_called_once_with(
self.firmware.get_legacy_bios_partition_size()
)
self.disk.create_efi_partition.assert_called_once_with(
self.firmware.get_efi_partition_size()
)
self.disk.create_boot_partition.assert_called_once_with(
self.disk_setup.boot_partition_size()
)
self.disk.create_prep_partition.assert_called_once_with(
self.firmware.get_prep_partition_size()
)
self.disk.create_root_partition.assert_called_once_with(
'all_free'
)
self.disk.map_partitions.assert_called_once_with()
self.bootloader_config.setup_disk_boot_images.assert_called_once_with(
'0815'
)
self.bootloader_config.setup_disk_image_config.assert_called_once_with(
uuid='0815', kernel='linux.vmx', initrd='initrd.vmx'
)
self.setup.call_edit_boot_config_script.assert_called_once_with(
'btrfs', 1
)
self.bootloader_install.install.assert_called_once_with()
self.setup.call_edit_boot_install_script.assert_called_once_with(
'target_dir/LimeJeOS-openSUSE-13.2.x86_64-1.13.2.raw',
'/dev/boot-device'
)
self.install_image.create_install_iso.assert_called_once_with()
self.install_image.create_install_pxe_archive.assert_called_once_with()
call = filesystem.create_on_device.call_args_list[0]
assert filesystem.create_on_device.call_args_list[0] == \
call(label='EFI')
call = filesystem.create_on_device.call_args_list[1]
assert filesystem.create_on_device.call_args_list[1] == \
call(label='BOOT')
call = filesystem.create_on_device.call_args_list[2]
assert filesystem.create_on_device.call_args_list[2] == \
call(label='ROOT')
call = filesystem.sync_data.call_args_list[0]
assert filesystem.sync_data.call_args_list[0] == \
call()
call = filesystem.sync_data.call_args_list[1]
assert filesystem.sync_data.call_args_list[1] == \
call(['efi/*'])
call = filesystem.sync_data.call_args_list[2]
assert filesystem.sync_data.call_args_list[2] == \
call([
'image', '.profile', '.kconfig', 'var/cache/kiwi',
'boot/*', 'boot/.*', 'boot/efi/*', 'boot/efi/.*'
])
assert mock_open.call_args_list == [
call('boot_dir/config.partids', 'w'),
call('root_dir/boot/mbrid', 'w'),
call('/dev/some-loop', 'wb')
]
assert file_mock.write.call_args_list == [
call('kiwi_BootPart="1"\n'),
call('kiwi_RootPart="1"\n'),
call('0x0f0f0f0f\n'),
call(b'\x0f\x0f\x0f\x0f')
]
assert mock_command.call_args_list == [
call(['cp', 'root_dir/recovery.partition.size', 'boot_dir']),
call(['mv', 'initrd', 'root_dir/boot/initrd.vmx']),
]
self.kernel.copy_kernel.assert_called_once_with(
'root_dir', '/boot/linux.vmx'
)
self.kernel.copy_xen_hypervisor.assert_called_once_with(
'root_dir', '/boot/xen.gz'
)
self.setup.export_rpm_package_list.assert_called_once_with(
'target_dir'
)
self.setup.export_rpm_package_verification.assert_called_once_with(
'target_dir'
)
@patch('kiwi.builder.disk.FileSystem')
@patch('builtins.open')
@patch('kiwi.builder.disk.Command.run')
def test_create_standard_root_dracut_initrd_system(
self, mock_command, mock_open, mock_fs
):
self.disk_builder.initrd_system = 'dracut'
kernel = mock.Mock()
kernel.version = '1.2.3'
self.kernel.get_kernel.return_value = kernel
self.disk_builder.create()
self.bootloader_config.setup_disk_image_config.assert_called_once_with(
uuid='0815', initrd='initrd-1.2.3', kernel='vmlinuz-1.2.3'
)
@patch('kiwi.builder.disk.FileSystem')
@patch('builtins.open')
@patch('kiwi.builder.disk.Command.run')
def test_create_standard_root_dracut_initrd_system_on_arm(
self, mock_command, mock_open, mock_fs
):
self.disk_builder.initrd_system = 'dracut'
self.disk_builder.arch = 'aarch64'
kernel = mock.Mock()
kernel.version = '1.2.3'
self.kernel.get_kernel.return_value = kernel
self.disk_builder.create()
self.bootloader_config.setup_disk_image_config.assert_called_once_with(
uuid='0815', initrd='initrd-1.2.3', kernel='zImage-1.2.3'
)
@patch('kiwi.builder.disk.FileSystem')
@patch('builtins.open')
@patch('kiwi.builder.disk.Command.run')
@raises(KiwiDiskBootImageError)
def test_create_standard_root_no_kernel_found(
self, mock_command, mock_open, mock_fs
):
self.kernel.get_kernel.return_value = False
self.disk_builder.create()
@patch('kiwi.builder.disk.FileSystem')
@patch('builtins.open')
@patch('kiwi.builder.disk.Command.run')
@raises(KiwiDiskBootImageError)
def test_create_standard_root_no_hypervisor_found(
self, mock_command, mock_open, mock_fs
):
self.kernel.get_xen_hypervisor.return_value = False
self.disk_builder.create()
@patch('kiwi.builder.disk.FileSystem')
@patch('builtins.open')
@patch('kiwi.builder.disk.Command.run')
def test_create_standard_root_s390_boot(
self, mock_command, mock_open, mock_fs
):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.firmware.efi_mode = mock.Mock(
return_value=False
)
self.disk_builder.bootloader = 'grub2_s390x_emu'
self.disk_builder.create()
assert mock_fs.call_args_list[1] == call(
'ext2', self.device_map['boot'], 'root_dir/boot/zipl/'
)
@patch('kiwi.builder.disk.FileSystem')
@patch('builtins.open')
@patch('kiwi.builder.disk.Command.run')
def test_create_standard_root_secure_boot(
self, mock_command, mock_open, mock_fs
):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.firmware.efi_mode = mock.Mock(
return_value='uefi'
)
self.disk_builder.create()
bootloader = self.bootloader_config
bootloader.setup_disk_boot_images.assert_called_once_with('0815')
@patch('kiwi.builder.disk.FileSystem')
@patch('builtins.open')
@patch('kiwi.builder.disk.Command.run')
def test_create_mdraid_root(self, mock_command, mock_open, mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.mdraid = 'mirroring'
self.disk_builder.create()
self.disk.create_root_raid_partition.assert_called_once_with(
'all_free'
)
self.raid_root.create_degraded_raid.assert_called_once_with(
raid_level='mirroring'
)
self.raid_root.create_raid_config.assert_called_once_with(
'boot_dir/etc/mdadm.conf'
)
@patch('kiwi.builder.disk.FileSystem')
@patch('builtins.open')
@patch('kiwi.builder.disk.Command.run')
def test_create_luks_root(self, mock_command, mock_open, mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.luks = 'passphrase'
self.disk_builder.create()
self.luks_root.create_crypto_luks.assert_called_once_with(
passphrase='passphrase', os=None
)
self.luks_root.create_crypttab.assert_called_once_with(
'root_dir/etc/crypttab'
)
@patch('kiwi.builder.disk.FileSystem')
@patch('kiwi.builder.disk.VolumeManager')
@patch('builtins.open')
@patch('kiwi.builder.disk.Command.run')
@patch('os.path.exists')
def test_create_volume_managed_root(
self, mock_exists, mock_command, mock_open, mock_volume_manager, mock_fs
):
mock_exists.return_value = True
volume_manager = mock.Mock()
volume_manager.get_device = mock.Mock(
return_value={
'root': MappedDevice('/dev/systemVG/LVRoot', mock.Mock())
}
)
mock_volume_manager.return_value = volume_manager
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = 'lvm'
self.disk_builder.create()
self.disk.create_root_lvm_partition.assert_called_once_with(
'all_free'
)
volume_manager.setup.assert_called_once_with('systemVG')
volume_manager.create_volumes.assert_called_once_with('btrfs')
volume_manager.sync_data.assert_called_once_with([
'image', '.profile', '.kconfig', 'var/cache/kiwi',
'boot/*', 'boot/.*', 'boot/efi/*', 'boot/efi/.*'
])
@patch('kiwi.builder.disk.FileSystem')
@patch('builtins.open')
@patch('kiwi.builder.disk.Command.run')
def test_create_hybrid_gpt_requested(
self, mock_command, mock_open, mock_fs
):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.install_media = False
self.disk_builder.hybrid_mbr = True
self.disk_builder.create()
self.disk.create_hybrid_mbr.assert_called_once_with()
@patch('kiwi.builder.disk.FileSystem')
@patch('builtins.open')
@patch('kiwi.builder.disk.Command.run')
def test_create_vboot_firmware_requested(
self, mock_command, mock_open, mock_fs
):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.install_media = False
self.disk_builder.firmware.vboot_mode.return_value = True
self.disk_builder.firmware.get_vboot_partition_size.return_value = 42
self.disk_builder.create()
self.disk.create_vboot_partition.assert_called_once_with(42)
@patch('kiwi.builder.disk.FileSystem')
@patch('builtins.open')
@patch('kiwi.builder.disk.Command.run')
def test_create_with_image_format(self, mock_command, mock_open, mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.install_media = False
self.disk_builder.image_format = 'vmdk'
self.disk_builder.create()
self.disk.subformat.create_image_format.assert_called_once_with()
@patch('kiwi.builder.disk.FileSystem')
@patch('builtins.open')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.logger.log.warning')
def test_create_with_ignore_format_on_install_media(
self, mock_log_warn, mock_command, mock_open, mock_fs
):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.install_media = True
self.disk_builder.image_format = 'vmdk'
self.disk_builder.create()
assert mock_log_warn.called
class TestDiskBuilder:
@patch('os.path.exists')
@patch('platform.machine')
def setup(self, mock_machine, mock_exists):
mock_machine.return_value = 'x86_64'
def side_effect(filename):
if filename.endswith('.config/kiwi/config.yml'):
return False
elif filename.endswith('etc/kiwi.yml'):
return False
else:
return True
mock_exists.side_effect = side_effect
description = XMLDescription('../data/example_disk_config.xml')
self.device_map = {
'root': MappedDevice('/dev/root-device', mock.Mock()),
'swap': MappedDevice('/dev/swap-device', mock.Mock()),
'readonly': MappedDevice('/dev/readonly-root-device', mock.Mock()),
'boot': MappedDevice('/dev/boot-device', mock.Mock()),
'prep': MappedDevice('/dev/prep-device', mock.Mock()),
'efi': MappedDevice('/dev/efi-device', mock.Mock()),
'spare': MappedDevice('/dev/spare-device', mock.Mock())
}
self.id_map = {'kiwi_RootPart': 1, 'kiwi_BootPart': 1}
self.id_map_sorted = OrderedDict(sorted(self.id_map.items()))
self.boot_names_type = namedtuple('boot_names_type',
['kernel_name', 'initrd_name'])
self.block_operation = mock.Mock()
self.block_operation.get_blkid = mock.Mock(return_value='blkid_result')
self.block_operation.get_filesystem = mock.Mock(
return_value='blkid_result_fs')
kiwi.builder.disk.BlockID = mock.Mock(
return_value=self.block_operation)
self.loop_provider = mock.Mock()
kiwi.builder.disk.LoopDevice = mock.Mock(
return_value=self.loop_provider)
self.disk = mock.Mock()
provider = mock.Mock()
provider.get_device = mock.Mock(return_value='/dev/some-loop')
self.disk.storage_provider = provider
self.partitioner = mock.Mock()
self.partitioner.get_id = mock.Mock(return_value=1)
self.disk.partitioner = self.partitioner
self.disk.get_uuid = mock.Mock(return_value='0815')
self.disk.get_public_partition_id_map = mock.Mock(
return_value=self.id_map_sorted)
self.disk.get_device = mock.Mock(return_value=self.device_map)
kernel_info = mock.Mock()
kernel_info.version = '1.2.3'
kernel_info.name = 'vmlinuz-1.2.3-default'
self.kernel = mock.Mock()
self.kernel.get_kernel = mock.Mock(return_value=kernel_info)
self.kernel.get_xen_hypervisor = mock.Mock()
self.kernel.copy_kernel = mock.Mock()
self.kernel.copy_xen_hypervisor = mock.Mock()
kiwi.builder.disk.Kernel = mock.Mock(return_value=self.kernel)
self.disk.subformat = mock.Mock()
self.disk.subformat.get_target_file_path_for_format = mock.Mock(
return_value='some-target-format-name')
kiwi.builder.disk.DiskFormat = mock.Mock(
return_value=self.disk.subformat)
kiwi.builder.disk.Disk = mock.Mock(return_value=self.disk)
self.disk_setup = mock.Mock()
self.disk_setup.get_disksize_mbytes.return_value = 1024
self.disk_setup.boot_partition_size.return_value = 0
self.disk_setup.get_efi_label = mock.Mock(return_value='EFI')
self.disk_setup.get_root_label = mock.Mock(return_value='ROOT')
self.disk_setup.get_boot_label = mock.Mock(return_value='BOOT')
self.disk_setup.need_boot_partition = mock.Mock(return_value=True)
self.bootloader_install = mock.Mock()
kiwi.builder.disk.BootLoaderInstall = mock.MagicMock(
return_value=self.bootloader_install)
self.bootloader_config = mock.Mock()
self.bootloader_config.get_boot_cmdline = mock.Mock(
return_value='boot_cmdline')
kiwi.builder.disk.BootLoaderConfig = mock.MagicMock(
return_value=self.bootloader_config)
kiwi.builder.disk.DiskSetup = mock.MagicMock(
return_value=self.disk_setup)
self.boot_image_task = mock.Mock()
self.boot_image_task.boot_root_directory = 'boot_dir'
self.boot_image_task.kernel_filename = 'kernel'
self.boot_image_task.initrd_filename = 'initrd'
self.boot_image_task.xen_hypervisor_filename = 'xen_hypervisor'
self.boot_image_task.get_boot_names.return_value = self.boot_names_type(
kernel_name='linux.vmx', initrd_name='initrd.vmx')
kiwi.builder.disk.BootImage = mock.Mock(
return_value=self.boot_image_task)
self.firmware = mock.Mock()
self.firmware.get_legacy_bios_partition_size.return_value = 0
self.firmware.get_efi_partition_size.return_value = 0
self.firmware.get_prep_partition_size.return_value = 0
self.firmware.efi_mode = mock.Mock(return_value='efi')
kiwi.builder.disk.FirmWare = mock.Mock(return_value=self.firmware)
self.setup = mock.Mock()
kiwi.builder.disk.SystemSetup = mock.Mock(return_value=self.setup)
self.install_image = mock.Mock()
kiwi.builder.disk.InstallImageBuilder = mock.Mock(
return_value=self.install_image)
self.raid_root = mock.Mock()
self.raid_root.get_device.return_value = MappedDevice(
'/dev/md0', mock.Mock())
kiwi.builder.disk.RaidDevice = mock.Mock(return_value=self.raid_root)
self.luks_root = mock.Mock()
kiwi.builder.disk.LuksDevice = mock.Mock(return_value=self.luks_root)
self.disk_builder = DiskBuilder(
XMLState(description.load()),
'target_dir',
'root_dir',
custom_args={'signing_keys': ['key_file_a', 'key_file_b']})
self.disk_builder.root_filesystem_is_overlay = False
self.disk_builder.build_type_name = 'oem'
self.disk_builder.image_format = None
def teardown(self):
sys.argv = argv_kiwi_tests
@patch('platform.machine')
def test_setup_ix86(self, mock_machine):
mock_machine.return_value = 'i686'
description = XMLDescription('../data/example_disk_config.xml')
disk_builder = DiskBuilder(XMLState(description.load()), 'target_dir',
'root_dir')
assert disk_builder.arch == 'ix86'
@patch('kiwi.builder.disk.FileSystem')
@patch('kiwi.builder.disk.Command.run')
def test_create_invalid_type_for_install_media(self, mock_cmd, mock_fs):
self.disk_builder.build_type_name = 'vmx'
with patch('builtins.open'):
with raises(KiwiInstallMediaError):
self.disk_builder.create_disk()
def test_create_disk_overlay_with_volume_setup_not_supported(self):
self.disk_builder.root_filesystem_is_overlay = True
self.disk_builder.volume_manager_name = 'lvm'
with raises(KiwiVolumeManagerSetupError):
self.disk_builder.create_disk()
@patch('os.path.exists')
@patch('pickle.load')
@patch('kiwi.builder.disk.Path.wipe')
def test_create_install_media(self, mock_wipe, mock_load, mock_path):
result_instance = mock.Mock()
mock_path.return_value = True
self.disk_builder.install_iso = True
self.disk_builder.install_pxe = True
with patch('builtins.open'):
self.disk_builder.create_install_media(result_instance)
self.install_image.create_install_iso.assert_called_once_with()
self.install_image.create_install_pxe_archive.assert_called_once_with()
mock_wipe.assert_called_once_with('target_dir/boot_image.pickledump')
@patch('os.path.exists')
def test_create_install_media_no_boot_instance_found(self, mock_path):
result_instance = mock.Mock()
mock_path.return_value = False
self.disk_builder.install_iso = True
with raises(KiwiInstallMediaError):
self.disk_builder.create_install_media(result_instance)
@patch('os.path.exists')
@patch('pickle.load')
def test_create_install_media_pickle_load_error(self, mock_load,
mock_path):
result_instance = mock.Mock()
mock_load.side_effect = Exception
mock_path.return_value = True
self.disk_builder.install_iso = True
with raises(KiwiInstallMediaError):
self.disk_builder.create_install_media(result_instance)
@patch('kiwi.builder.disk.FileSystem')
@patch('random.randrange')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
@patch('os.path.exists')
def test_create_disk_standard_root_with_kiwi_initrd(
self, mock_path, mock_grub_dir, mock_command, mock_rand, mock_fs):
mock_path.return_value = True
mock_rand.return_value = 15
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.initrd_system = 'kiwi'
m_open = mock_open()
with patch('builtins.open', m_open, create=True):
self.disk_builder.create_disk()
self.setup.create_recovery_archive.assert_called_once_with()
call = self.setup.export_modprobe_setup.call_args_list[0]
assert self.setup.export_modprobe_setup.call_args_list[0] == \
call('boot_dir')
self.setup.set_selinux_file_contexts.assert_called_once_with(
'/etc/selinux/targeted/contexts/files/file_contexts')
self.disk_setup.get_disksize_mbytes.assert_called_once_with()
self.loop_provider.create.assert_called_once_with()
self.disk.wipe.assert_called_once_with()
self.disk.create_efi_csm_partition.assert_called_once_with(
self.firmware.get_legacy_bios_partition_size())
self.disk.create_efi_partition.assert_called_once_with(
self.firmware.get_efi_partition_size())
self.disk.create_boot_partition.assert_called_once_with(
self.disk_setup.boot_partition_size())
self.disk.create_swap_partition.assert_called_once_with(128)
self.disk.create_prep_partition.assert_called_once_with(
self.firmware.get_prep_partition_size())
self.disk.create_root_partition.assert_called_once_with('all_free')
self.disk.map_partitions.assert_called_once_with()
self.bootloader_config.setup_disk_boot_images.assert_called_once_with(
'0815')
self.bootloader_config.write_meta_data.assert_called_once_with(
boot_options='', root_uuid='0815')
self.bootloader_config.setup_disk_image_config.assert_called_once_with(
boot_options={
'boot_device': '/dev/boot-device',
'root_device': '/dev/readonly-root-device',
'firmware': self.firmware,
'target_removable': None,
'efi_device': '/dev/efi-device',
'prep_device': '/dev/prep-device'
})
self.setup.call_edit_boot_config_script.assert_called_once_with(
'btrfs', 1)
self.bootloader_install.install.assert_called_once_with()
self.setup.call_edit_boot_install_script.assert_called_once_with(
'target_dir/LimeJeOS-openSUSE-13.2.x86_64-1.13.2.raw',
'/dev/boot-device')
self.boot_image_task.prepare.assert_called_once_with()
call = filesystem.create_on_device.call_args_list[0]
assert filesystem.create_on_device.call_args_list[0] == \
call(label='EFI')
call = filesystem.create_on_device.call_args_list[1]
assert filesystem.create_on_device.call_args_list[1] == \
call(label='BOOT')
call = filesystem.create_on_device.call_args_list[2]
assert filesystem.create_on_device.call_args_list[2] == \
call(label='ROOT')
call = filesystem.sync_data.call_args_list[0]
assert filesystem.sync_data.call_args_list[0] == \
call()
call = filesystem.sync_data.call_args_list[1]
assert filesystem.sync_data.call_args_list[1] == \
call(['efi/*'])
call = filesystem.sync_data.call_args_list[2]
assert filesystem.sync_data.call_args_list[2] == \
call([
'image', '.profile', '.kconfig', '.buildenv', 'var/cache/kiwi',
'boot/*', 'boot/.*', 'boot/efi/*', 'boot/efi/.*'
])
assert m_open.call_args_list[0:4] == [
call('boot_dir/config.partids', 'w'),
call('root_dir/boot/mbrid', 'w'),
call('boot_dir/config.bootoptions', 'w'),
call('/dev/some-loop', 'wb')
]
assert m_open.return_value.write.call_args_list == [
call('kiwi_BootPart="1"\n'),
call('kiwi_RootPart="1"\n'),
call('0x0f0f0f0f\n'),
call('boot_cmdline\n'),
call(bytes(b'\x0f\x0f\x0f\x0f')),
]
assert mock_command.call_args_list == [
call(['cp', 'root_dir/recovery.partition.size', 'boot_dir']),
call(['mv', 'initrd', 'root_dir/boot/initrd.vmx']),
]
self.setup.export_package_list.assert_called_once_with('target_dir')
self.setup.export_package_verification.assert_called_once_with(
'target_dir')
@patch('kiwi.builder.disk.FileSystem')
@patch('random.randrange')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
@patch('os.path.exists')
def test_create_disk_standard_root_with_dracut_initrd(
self, mock_path, mock_grub_dir, mock_command, mock_rand, mock_fs):
self.boot_image_task.get_boot_names.return_value = self.boot_names_type(
kernel_name='vmlinuz-1.2.3-default',
initrd_name='initramfs-1.2.3.img')
mock_path.return_value = True
mock_rand.return_value = 15
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.initrd_system = 'dracut'
m_open = mock_open()
with patch('builtins.open', m_open, create=True):
self.disk_builder.create_disk()
self.setup.create_recovery_archive.assert_called_once_with()
self.setup.set_selinux_file_contexts.assert_called_once_with(
'/etc/selinux/targeted/contexts/files/file_contexts')
self.disk_setup.get_disksize_mbytes.assert_called_once_with()
self.loop_provider.create.assert_called_once_with()
self.disk.wipe.assert_called_once_with()
self.disk.create_efi_csm_partition.assert_called_once_with(
self.firmware.get_legacy_bios_partition_size())
self.disk.create_efi_partition.assert_called_once_with(
self.firmware.get_efi_partition_size())
self.disk.create_boot_partition.assert_called_once_with(
self.disk_setup.boot_partition_size())
self.disk.create_prep_partition.assert_called_once_with(
self.firmware.get_prep_partition_size())
self.disk.create_root_partition.assert_called_once_with('all_free')
self.disk.map_partitions.assert_called_once_with()
self.bootloader_config.setup_disk_boot_images.assert_called_once_with(
'0815')
self.bootloader_config.write_meta_data.assert_called_once_with(
boot_options='', root_uuid='0815')
self.bootloader_config.setup_disk_image_config.assert_called_once_with(
boot_options={
'boot_device': '/dev/boot-device',
'root_device': '/dev/readonly-root-device',
'firmware': self.firmware,
'target_removable': None,
'efi_device': '/dev/efi-device',
'prep_device': '/dev/prep-device'
})
self.setup.call_edit_boot_config_script.assert_called_once_with(
'btrfs', 1)
self.bootloader_install.install.assert_called_once_with()
self.setup.call_edit_boot_install_script.assert_called_once_with(
'target_dir/LimeJeOS-openSUSE-13.2.x86_64-1.13.2.raw',
'/dev/boot-device')
self.boot_image_task.prepare.assert_called_once_with()
call = filesystem.create_on_device.call_args_list[0]
assert filesystem.create_on_device.call_args_list[0] == \
call(label='EFI')
call = filesystem.create_on_device.call_args_list[1]
assert filesystem.create_on_device.call_args_list[1] == \
call(label='BOOT')
call = filesystem.create_on_device.call_args_list[2]
assert filesystem.create_on_device.call_args_list[2] == \
call(label='ROOT')
call = filesystem.sync_data.call_args_list[0]
assert filesystem.sync_data.call_args_list[0] == \
call()
call = filesystem.sync_data.call_args_list[1]
assert filesystem.sync_data.call_args_list[1] == \
call(['efi/*'])
call = filesystem.sync_data.call_args_list[2]
assert filesystem.sync_data.call_args_list[2] == \
call([
'image', '.profile', '.kconfig', '.buildenv', 'var/cache/kiwi',
'boot/*', 'boot/.*', 'boot/efi/*', 'boot/efi/.*'
])
assert m_open.call_args_list == [
call('boot_dir/config.partids', 'w'),
call('root_dir/boot/mbrid', 'w'),
call('boot_dir/config.bootoptions', 'w'),
call('/dev/some-loop', 'wb')
]
assert m_open.return_value.write.call_args_list == [
call('kiwi_BootPart="1"\n'),
call('kiwi_RootPart="1"\n'),
call('0x0f0f0f0f\n'),
call('boot_cmdline\n'),
call(bytes(b'\x0f\x0f\x0f\x0f'))
]
assert mock_command.call_args_list == [
call(['cp', 'root_dir/recovery.partition.size', 'boot_dir']),
call(['mv', 'initrd', 'root_dir/boot/initramfs-1.2.3.img'])
]
self.setup.export_package_list.assert_called_once_with('target_dir')
self.setup.export_package_verification.assert_called_once_with(
'target_dir')
assert self.boot_image_task.include_file.call_args_list == [
call('/config.partids'),
call('/recovery.partition.size')
]
self.boot_image_task.include_module.assert_called_once_with(
'kiwi-repart')
self.boot_image_task.omit_module.assert_called_once_with('multipath')
assert self.boot_image_task.write_system_config_file.call_args_list == \
[]
@patch('kiwi.builder.disk.FileSystem')
@patch('kiwi.builder.disk.FileSystemSquashFs')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
@patch('os.path.exists')
@patch('os.path.getsize')
@patch('kiwi.builder.disk.NamedTemporaryFile')
@patch('random.randrange')
def test_create_disk_standard_root_is_overlay(self, mock_rand, mock_temp,
mock_getsize, mock_exists,
mock_grub_dir, mock_command,
mock_squashfs, mock_fs):
mock_rand.return_value = 15
self.disk_builder.root_filesystem_is_overlay = True
self.disk_builder.volume_manager_name = None
squashfs = mock.Mock()
mock_squashfs.return_value = squashfs
mock_getsize.return_value = 1048576
tempfile = mock.Mock()
tempfile.name = 'tempname'
mock_temp.return_value = tempfile
mock_exists.return_value = True
self.disk_builder.initrd_system = 'dracut'
m_open = mock_open()
with patch('builtins.open', m_open, create=True):
self.disk_builder.create_disk()
assert mock_squashfs.call_args_list == [
call(device_provider=None, root_dir='root_dir'),
call(device_provider=None, root_dir='root_dir')
]
assert squashfs.create_on_file.call_args_list == [
call(exclude=['var/cache/kiwi'], filename='tempname'),
call(exclude=[
'image', '.profile', '.kconfig', '.buildenv', 'var/cache/kiwi',
'boot/*', 'boot/.*', 'boot/efi/*', 'boot/efi/.*'
],
filename='tempname')
]
self.disk.create_root_readonly_partition.assert_called_once_with(11)
assert mock_command.call_args_list[2] == call(
['dd', 'if=tempname', 'of=/dev/readonly-root-device'])
assert m_open.return_value.write.call_args_list == [
call('kiwi_BootPart="1"\n'),
call('kiwi_RootPart="1"\n'),
call('0x0f0f0f0f\n'),
call('boot_cmdline\n'),
call(b'\x0f\x0f\x0f\x0f')
]
assert self.boot_image_task.include_module.call_args_list == [
call('kiwi-overlay'), call('kiwi-repart')
]
self.boot_image_task.omit_module.assert_called_once_with('multipath')
self.boot_image_task.write_system_config_file.assert_called_once_with(
config={'modules': ['kiwi-overlay']})
@patch('kiwi.builder.disk.FileSystem')
@patch('kiwi.builder.disk.Command.run')
def test_create_disk_standard_root_no_hypervisor_found(
self, mock_command, mock_fs):
self.kernel.get_xen_hypervisor.return_value = False
self.disk_builder.volume_manager_name = None
self.disk_builder.xen_server = True
with patch('builtins.open'):
with raises(KiwiDiskBootImageError):
self.disk_builder.create_disk()
@patch('kiwi.builder.disk.FileSystem')
@patch('kiwi.builder.disk.Command.run')
def test_create_disk_standard_root_xen_server_boot(self, mock_command,
mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.xen_server = True
self.firmware.efi_mode = mock.Mock(return_value=False)
with patch('builtins.open'):
self.disk_builder.create_disk()
self.kernel.copy_xen_hypervisor.assert_called_once_with(
'root_dir', '/boot/xen.gz')
@patch('kiwi.builder.disk.FileSystem')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_standard_root_s390_boot(self, mock_grub_dir,
mock_command, mock_fs):
self.disk_builder.arch = 's390x'
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.firmware.efi_mode = mock.Mock(return_value=False)
self.disk_builder.bootloader = 'grub2_s390x_emu'
with patch('builtins.open'):
self.disk_builder.create_disk()
self.bootloader_config.write.assert_called_once_with()
assert mock_fs.call_args_list[1] == call('ext2',
self.device_map['boot'],
'root_dir/boot/zipl/')
@patch('kiwi.builder.disk.FileSystem')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_standard_root_secure_boot(self, mock_grub_dir,
mock_command, mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.firmware.efi_mode = mock.Mock(return_value='uefi')
with patch('builtins.open'):
self.disk_builder.create_disk()
bootloader = self.bootloader_config
bootloader.setup_disk_boot_images.assert_called_once_with('0815')
@patch('kiwi.builder.disk.FileSystem')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_mdraid_root(self, mock_grub_dir, mock_command,
mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.mdraid = 'mirroring'
self.disk.public_partition_id_map = self.id_map
with patch('builtins.open'):
self.disk_builder.create_disk()
self.disk.create_root_raid_partition.assert_called_once_with(
'all_free')
self.raid_root.create_degraded_raid.assert_called_once_with(
raid_level='mirroring')
self.raid_root.create_raid_config.assert_called_once_with(
'boot_dir/etc/mdadm.conf')
assert self.disk.public_partition_id_map == {
'kiwi_RaidPart': 1,
'kiwi_RootPart': 1,
'kiwi_BootPart': 1,
'kiwi_RaidDev': '/dev/md0'
}
@patch('kiwi.builder.disk.FileSystem')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_luks_root(self, mock_grub_dir, mock_command, mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.luks = 'passphrase'
self.disk_setup.need_boot_partition.return_value = False
self.disk_builder.boot_is_crypto = True
with patch('builtins.open'):
self.disk_builder.create_disk()
self.luks_root.create_crypto_luks.assert_called_once_with(
passphrase='passphrase', os=None, keyfile='root_dir/.root.keyfile')
self.luks_root.create_crypttab.assert_called_once_with(
'root_dir/etc/crypttab')
assert self.boot_image_task.include_file.call_args_list == [
call('/.root.keyfile'),
call('/config.partids'),
call('/etc/crypttab')
]
self.boot_image_task.write_system_config_file.assert_called_once_with(
config={'install_items': ['/.root.keyfile']},
config_file='root_dir/etc/dracut.conf.d/99-luks-boot.conf')
@patch('kiwi.builder.disk.FileSystem')
@patch('kiwi.builder.disk.VolumeManager')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
@patch('os.path.exists')
def test_create_disk_volume_managed_root(self, mock_exists, mock_grub_dir,
mock_command, mock_volume_manager,
mock_fs):
mock_exists.return_value = True
volume_manager = mock.Mock()
volume_manager.get_device = mock.Mock(
return_value={
'root': MappedDevice('/dev/systemVG/LVRoot', mock.Mock()),
'swap': MappedDevice('/dev/systemVG/LVSwap', mock.Mock())
})
volume_manager.get_fstab = mock.Mock(
return_value=['fstab_volume_entries'])
mock_volume_manager.return_value = volume_manager
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = 'lvm'
with patch('builtins.open'):
self.disk_builder.create_disk()
self.disk.create_root_lvm_partition.assert_called_once_with('all_free')
volume_manager.setup.assert_called_once_with('systemVG')
volume_manager.create_volumes.assert_called_once_with('btrfs')
volume_manager.mount_volumes.call_args_list[0].assert_called_once_with(
)
volume_manager.get_fstab.assert_called_once_with(None, 'btrfs')
volume_manager.sync_data.assert_called_once_with([
'image', '.profile', '.kconfig', '.buildenv', 'var/cache/kiwi',
'boot/*', 'boot/.*', 'boot/efi/*', 'boot/efi/.*'
])
volume_manager.umount_volumes.call_args_list[
0].assert_called_once_with()
self.setup.create_fstab.assert_called_once_with([
'fstab_volume_entries',
'UUID=blkid_result / blkid_result_fs ro 0 0',
'/dev/systemVG/LVSwap swap swap defaults 0 0',
'UUID=blkid_result /boot blkid_result_fs defaults 0 0',
'UUID=blkid_result /boot/efi blkid_result_fs defaults 0 0'
])
self.boot_image_task.setup.create_fstab.assert_called_once_with([
'fstab_volume_entries',
'UUID=blkid_result / blkid_result_fs ro 0 0',
'/dev/systemVG/LVSwap swap swap defaults 0 0',
'UUID=blkid_result /boot blkid_result_fs defaults 0 0',
'UUID=blkid_result /boot/efi blkid_result_fs defaults 0 0'
])
@patch('kiwi.builder.disk.FileSystem')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_hybrid_gpt_requested(self, mock_grub_dir,
mock_command, mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.install_media = False
self.disk_builder.hybrid_mbr = True
with patch('builtins.open'):
self.disk_builder.create_disk()
self.disk.create_hybrid_mbr.assert_called_once_with()
@patch('kiwi.builder.disk.FileSystem')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_force_mbr_requested(self, mock_grub_dir, mock_command,
mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.install_media = False
self.disk_builder.force_mbr = True
with patch('builtins.open'):
self.disk_builder.create_disk()
self.disk.create_mbr.assert_called_once_with()
@patch('kiwi.builder.disk.DiskBuilder')
def test_create(self, mock_builder):
result = mock.Mock()
builder = mock.Mock()
builder.create_disk.return_value = result
builder.create_install_media.return_value = result
mock_builder.return_value = builder
self.disk_builder.create()
builder.create_disk.assert_called_once_with()
builder.create_install_media.assert_called_once_with(result)
builder.append_unpartitioned_space.assert_called_once_with()
builder.create_disk_format.assert_called_once_with(result)
@patch('kiwi.builder.disk.FileSystem')
@patch('kiwi.builder.disk.Command.run')
@patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
def test_create_disk_spare_part_requested(self, mock_grub_dir,
mock_command, mock_fs):
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.volume_manager_name = None
self.disk_builder.install_media = False
self.disk_builder.spare_part_mbsize = 42
self.disk_builder.spare_part_fs = 'ext4'
self.disk_builder.spare_part_mountpoint = '/var'
self.disk_builder.spare_part_is_last = False
with patch('builtins.open'):
self.disk_builder.create_disk()
self.disk.create_spare_partition.assert_called_once_with(42)
assert mock_fs.call_args_list[0] == call(
self.disk_builder.spare_part_fs, self.device_map['spare'],
'root_dir/var/')
assert filesystem.sync_data.call_args_list.pop() == call([
'image', '.profile', '.kconfig', '.buildenv', 'var/cache/kiwi',
'var/*', 'var/.*', 'boot/*', 'boot/.*', 'boot/efi/*', 'boot/efi/.*'
])
assert 'UUID=blkid_result /var blkid_result_fs defaults 0 0' in \
self.disk_builder.generic_fstab_entries
self.disk.create_root_partition.reset_mock()
self.disk.create_spare_partition.reset_mock()
self.disk_builder.spare_part_is_last = True
with patch('builtins.open'):
self.disk_builder.create_disk()
self.disk.create_spare_partition.assert_called_once_with('all_free')
@patch('kiwi.builder.disk.LoopDevice')
@patch('kiwi.builder.disk.Partitioner')
@patch('kiwi.builder.disk.DiskFormat')
def test_append_unpartitioned_space(self, mock_diskformat,
mock_partitioner, mock_loopdevice):
loopdevice = mock.Mock()
mock_loopdevice.return_value = loopdevice
partitioner = mock.Mock()
mock_partitioner.return_value = partitioner
disk_format = mock.Mock()
mock_diskformat.return_value = disk_format
self.disk_builder.unpartitioned_bytes = 1024
self.disk_builder.append_unpartitioned_space()
disk_format.resize_raw_disk.assert_called_once_with(1024, append=True)
loopdevice.create.assert_called_once_with(overwrite=False)
assert partitioner.resize_table.called
@patch('kiwi.builder.disk.FileSystem')
@patch('kiwi.builder.disk.Command.run')
def test_create_disk_format(self, mock_command, mock_fs):
result_instance = mock.Mock()
filesystem = mock.Mock()
mock_fs.return_value = filesystem
self.disk_builder.install_media = False
self.disk_builder.image_format = 'vmdk'
with patch('builtins.open'):
self.disk_builder.create_disk_format(result_instance)
self.disk.subformat.create_image_format.assert_called_once_with()
