From e545e9a1c2ed4b1c5e77f95fb1cc4311ed1f42dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marcus=20Sch=C3=A4fer?= Date: Sun, 4 Feb 2024 15:24:18 +0100 Subject: [PATCH] Move Raid Luks and Integrity context manager Change the RaidDevice, LuksDevice and IntegrityDevice classes to context manager. All code using this classes moved to: with RaidDevice(...) as raid: raid.some_member() with LuksDevice(...) as luks: luks.some_member() with IntegrityDevice(...) as integrity: integrity.some_member() In addition to the context manager move, the use of them has been refactored into a nested structure of supported device layouts inside the disk builder. This is related to Issue #2412 --- kiwi/builder/disk.py | 81 +++++-- kiwi/storage/integrity_device.py | 15 +- kiwi/storage/luks_device.py | 15 +- kiwi/storage/raid_device.py | 15 +- test/unit/builder/disk_test.py | 262 ++++++++++++++++++--- test/unit/storage/integrity_device_test.py | 18 +- test/unit/storage/luks_device_test.py | 18 +- test/unit/storage/raid_device_test.py | 18 +- 8 files changed, 352 insertions(+), 90 deletions(-) diff --git a/kiwi/builder/disk.py b/kiwi/builder/disk.py index 9318efb43e4..e6caea0e94f 100644 --- a/kiwi/builder/disk.py +++ b/kiwi/builder/disk.py @@ -349,26 +349,66 @@ def create_disk(self) -> Result: disk.public_partition_id_map['kiwi_RootPart'] = \ disk.public_partition_id_map['kiwi_ROPart'] - # create raid on current root device if requested if self.mdraid: - raid_root = self._raid_instance(device_map) - device_map = self._map_raid(device_map, disk, raid_root) - - # create integrity on current root device if requested - if self.integrity: - integrity_root = self._integrity_instance(device_map) - device_map = self._map_integrity(device_map, integrity_root) - - # create luks on current root device if requested - if self.luks is not None: - luks_root = self._luks_instance(device_map) - device_map = self._map_luks(device_map, luks_root) - - # create system layout for root system - self._create_system_instance(device_map) - - # sync system data, configure system, setup loader and initrd - self._process_build(device_map, disk) + # create raid on root dev + with self._raid_instance(device_map) as raid_root: + device_map = self._map_raid( + device_map, disk, raid_root + ) + if self.integrity: + # create integrity on raid root dev + with self._integrity_instance( + device_map + ) as integrity_root: + device_map = self._map_integrity( + device_map, integrity_root + ) + if self.luks is not None: + with self._luks_instance( + device_map + ) as luks_root: + # create luks on raid+integrity root dev + device_map = self._map_luks( + device_map, luks_root + ) + # build bootable raid+integrity+luks disk + self._process_build(device_map, disk) + else: + # build bootable raid+integrity disk + self._process_build(device_map, disk) + elif self.luks is not None: + with self._luks_instance(device_map) as luks_root: + # create luks on raid root dev + device_map = self._map_luks(device_map, luks_root) + # build bootable raid+luks disk + self._process_build(device_map, disk) + else: + # build bootable raid disk + self._process_build(device_map, disk) + elif self.integrity: + # create integrity on root dev + with self._integrity_instance(device_map) as integrity_root: + device_map = self._map_integrity( + device_map, integrity_root + ) + if self.luks is not None: + with self._luks_instance(device_map) as luks_root: + # create luks on integrity root dev + device_map = self._map_luks(device_map, luks_root) + # build bootable integrity+luks disk + self._process_build(device_map, disk) + else: + # build bootable integrity disk + self._process_build(device_map, disk) + elif self.luks is not None: + with self._luks_instance(device_map) as luks_root: + # create luks on root dev + device_map = self._map_luks(device_map, luks_root) + # build bootable luks disk + self._process_build(device_map, disk) + else: + # build bootable disk + self._process_build(device_map, disk) # store image bundle_format in result if self.bundle_format: @@ -703,6 +743,9 @@ def _map_root_filesystem( self.storage_map['system'] = filesystem def _process_build(self, device_map: Dict, disk: Disk) -> None: + # create system layout for root system + self._create_system_instance(device_map) + # representing the entire image system except for the boot/ area # which could live on another part of the disk system: Optional[Union[FileSystemBase, VolumeManagerBase]] = \ diff --git a/kiwi/storage/integrity_device.py b/kiwi/storage/integrity_device.py index 41d0407f0df..a487f6cfcc7 100644 --- a/kiwi/storage/integrity_device.py +++ b/kiwi/storage/integrity_device.py @@ -99,6 +99,9 @@ def __init__( self.integrity_metadata_file: Optional[IO[bytes]] = None self.credentials = credentials + def __enter__(self): + return self + def get_device(self) -> Optional[MappedDevice]: """ Instance of MappedDevice providing the dm_integrity device @@ -298,15 +301,15 @@ def _get_integrity_superblock(self) -> Dict[str, Union[str, List[str]]]: integrity[entry[0]] = entry[1] return integrity - def __del__(self): + def __exit__(self, exc_type, exc_value, traceback): if self.integrity_device: - log.info('Cleaning up %s instance', type(self).__name__) try: Command.run( ['integritysetup', 'close', self.integrity_name] ) - except Exception: - log.warning( - 'Shutdown of integrity map %s failed, %s still busy', - self.integrity_name, self.integrity_device + except Exception as issue: + log.error( + 'Shutdown of integrity map {0}:{1} failed with {2}'.format( + self.integrity_name, self.integrity_device, issue + ) ) diff --git a/kiwi/storage/luks_device.py b/kiwi/storage/luks_device.py index ad3b2fa07c4..624cdca9fcf 100644 --- a/kiwi/storage/luks_device.py +++ b/kiwi/storage/luks_device.py @@ -57,6 +57,9 @@ def __init__(self, storage_provider: DeviceProvider) -> None: ] } + def __enter__(self): + return self + def get_device(self) -> Optional[MappedDevice]: """ Instance of MappedDevice providing the luks device @@ -208,15 +211,15 @@ def create_random_keyfile(filename: str) -> None: keyfile.write(os.urandom(Defaults.get_luks_key_length())) os.chmod(filename, 0o600) - def __del__(self): + def __exit__(self, exc_type, exc_value, traceback): if self.luks_device: - log.info('Cleaning up %s instance', type(self).__name__) try: Command.run( ['cryptsetup', 'luksClose', self.luks_name] ) - except Exception: - log.warning( - 'Shutdown of luks map %s failed, %s still busy', - self.luks_name, self.luks_device + except Exception as issue: + log.error( + 'Shutdown of luks map {0}:{1} failed with: {2}'.format( + self.luks_name, self.luks_device, issue + ) ) diff --git a/kiwi/storage/raid_device.py b/kiwi/storage/raid_device.py index 0c7c400c259..58394079241 100644 --- a/kiwi/storage/raid_device.py +++ b/kiwi/storage/raid_device.py @@ -49,6 +49,9 @@ def __init__(self, storage_provider: DeviceProvider): } self.raid_device = None + def __enter__(self): + return self + def get_device(self) -> Optional[MappedDevice]: """ Instance of MappedDevice providing the raid device @@ -123,15 +126,15 @@ def is_loop(self) -> bool: """ return self.storage_provider.is_loop() - def __del__(self): + def __exit__(self, exc_type, exc_value, traceback): if self.raid_device: - log.info('Cleaning up %s instance', type(self).__name__) try: Command.run( ['mdadm', '--stop', self.raid_device] ) - except Exception: - log.warning( - 'Shutdown of raid device failed, %s still busy', - self.raid_device + except Exception as issue: + log.error( + 'Shutdown of raid device {0} failed with: {1}'.format( + self.raid_device, issue + ) ) diff --git a/test/unit/builder/disk_test.py b/test/unit/builder/disk_test.py index 0fa4867b32e..936a3f90783 100644 --- a/test/unit/builder/disk_test.py +++ b/test/unit/builder/disk_test.py @@ -152,24 +152,6 @@ def side_effect(filename): 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.integrity_root = Mock() - self.integrity_root.get_device.return_value = MappedDevice( - '/dev/integrityRoot', Mock() - ) - kiwi.builder.disk.IntegrityDevice = Mock( - return_value=self.integrity_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 @@ -596,6 +578,7 @@ def test_create_disk_standard_root_with_clone( call([self.device_map['rootclone1']]) ] + @patch('kiwi.builder.disk.IntegrityDevice') @patch('kiwi.builder.disk.Disk') @patch('kiwi.builder.disk.create_boot_loader_config') @patch('kiwi.builder.disk.FileSystem.new') @@ -610,8 +593,10 @@ def test_create_disk_standard_root_with_dm_integrity( self, mock_Temporary_new_file, mock_ImageSystem, mock_SystemSetup, mock_os_path_getsize, mock_path, mock_grub_dir, mock_command, mock_fs, mock_create_boot_loader_config, - mock_Disk + mock_Disk, mock_IntegrityDevice ): + integrity = self._get_integrity_instance() + mock_IntegrityDevice.return_value.__enter__.return_value = integrity mock_Disk.return_value.__enter__.return_value = \ self._get_disk_instance() bootloader_config = Mock() @@ -631,7 +616,10 @@ def test_create_disk_standard_root_with_dm_integrity( mock_path.return_value = True filesystem = Mock() mock_fs.return_value.__enter__.return_value = filesystem + + # cover integrity self.disk_builder.integrity = True + self.disk_builder.luks = None self.disk_builder.integrity_legacy_hmac = True self.disk_builder.root_filesystem_embed_integrity_metadata = True self.disk_builder.root_filesystem_is_overlay = False @@ -644,12 +632,33 @@ def test_create_disk_standard_root_with_dm_integrity( with patch('builtins.open', m_open, create=True): self.disk_builder.create_disk() - self.integrity_root.create_integritytab.assert_called_once_with( + integrity.create_integritytab.assert_called_once_with( + 'root_dir/etc/integritytab' + ) + integrity.create_integrity_metadata.assert_called_once_with() + integrity.sign_integrity_metadata.assert_called_once_with() + integrity.write_integrity_metadata.assert_called_once_with() + assert filesystem.create_on_device.call_args_list == [ + call(label='EFI'), + call(label='BOOT'), + # root must be created DM_METADATA_OFFSET smaller + call(label='ROOT', size=-4096, unit='b'), + call(label='SWAP') + ] + + # cover integrity+luks + self.disk_builder.luks = 'secret' + integrity.reset_mock() + filesystem.reset_mock() + with patch('builtins.open', m_open, create=True): + self.disk_builder.create_disk() + + integrity.create_integritytab.assert_called_once_with( 'root_dir/etc/integritytab' ) - self.integrity_root.create_integrity_metadata.assert_called_once_with() - self.integrity_root.sign_integrity_metadata.assert_called_once_with() - self.integrity_root.write_integrity_metadata.assert_called_once_with() + integrity.create_integrity_metadata.assert_called_once_with() + integrity.sign_integrity_metadata.assert_called_once_with() + integrity.write_integrity_metadata.assert_called_once_with() assert filesystem.create_on_device.call_args_list == [ call(label='EFI'), call(label='BOOT'), @@ -876,6 +885,7 @@ def test_create_disk_standard_root_with_fixed_rootfs_size( 'clone:1024:1024', 1 ) + @patch('kiwi.builder.disk.IntegrityDevice') @patch('kiwi.builder.disk.Disk') @patch('kiwi.builder.disk.create_boot_loader_config') @patch('kiwi.builder.disk.LoopDevice') @@ -894,8 +904,10 @@ def test_create_disk_standard_root_is_overlay( mock_getsize, mock_exists, mock_grub_dir, mock_command, mock_squashfs, mock_fs, mock_DeviceProvider, mock_LoopDevice, mock_create_boot_loader_config, - mock_Disk + mock_Disk, mock_IntegrityDevice ): + integrity = self._get_integrity_instance() + mock_IntegrityDevice.return_value.__enter__.return_value = integrity disk = self._get_disk_instance() mock_Disk.return_value.__enter__.return_value = disk bootloader_config = Mock() @@ -955,9 +967,9 @@ def test_create_disk_standard_root_is_overlay( squashfs.create_verification_metadata.assert_called_once_with( '/dev/integrityRoot' ) - self.integrity_root.create_integrity_metadata.assert_called_once_with() - self.integrity_root.sign_integrity_metadata.assert_called_once_with() - self.integrity_root.write_integrity_metadata.assert_called_once_with() + integrity.create_integrity_metadata.assert_called_once_with() + integrity.sign_integrity_metadata.assert_called_once_with() + integrity.write_integrity_metadata.assert_called_once_with() disk.create_root_readonly_partition.assert_called_once_with( 11, 0 ) @@ -1093,6 +1105,161 @@ def test_create_disk_standard_root_secure_boot( '0815' ) + @patch('os.path.exists') + @patch('kiwi.builder.disk.RaidDevice') + @patch('kiwi.builder.disk.Disk') + @patch('kiwi.builder.disk.create_boot_loader_config') + @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_on_integrity_root( + self, mock_grub_dir, mock_command, mock_fs, + mock_create_boot_loader_config, mock_Disk, mock_RaidDevice, + mock_os_path_exists + ): + mock_os_path_exists.return_value = True + raid_root = Mock() + raid_root.get_device.return_value = MappedDevice( + '/dev/md0', Mock() + ) + mock_RaidDevice.return_value.__enter__.return_value = raid_root + disk = self._get_disk_instance() + mock_Disk.return_value.__enter__.return_value = disk + bootloader_config = Mock() + bootloader_config.get_boot_cmdline = Mock( + return_value='boot_cmdline' + ) + mock_create_boot_loader_config.return_value.__enter__.return_value = \ + bootloader_config + filesystem = Mock() + mock_fs.return_value.__enter__.return_value = filesystem + self.disk_builder.volume_manager_name = None + self.disk_builder.mdraid = 'mirroring' + self.disk_builder.integrity = True + self.disk_builder.luks = None + disk.public_partition_id_map = self.id_map + + with patch('builtins.open'): + self.disk_builder.create_disk() + + disk.create_root_raid_partition.assert_called_once_with( + 'all_free', 0 + ) + raid_root.create_degraded_raid.assert_called_once_with( + raid_level='mirroring' + ) + raid_root.create_raid_config.assert_called_once_with( + 'boot_dir/etc/mdadm.conf' + ) + assert disk.public_partition_id_map == { + 'kiwi_RaidPart': 1, 'kiwi_RootPart': 1, 'kiwi_BootPart': 1, + 'kiwi_RaidDev': '/dev/md0' + } + + @patch('os.path.exists') + @patch('kiwi.builder.disk.RaidDevice') + @patch('kiwi.builder.disk.Disk') + @patch('kiwi.builder.disk.create_boot_loader_config') + @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_on_integrity_on_luks_root( + self, mock_grub_dir, mock_command, mock_fs, + mock_create_boot_loader_config, mock_Disk, mock_RaidDevice, + mock_os_path_exists + ): + mock_os_path_exists.return_value = True + raid_root = Mock() + raid_root.get_device.return_value = MappedDevice( + '/dev/md0', Mock() + ) + mock_RaidDevice.return_value.__enter__.return_value = raid_root + disk = self._get_disk_instance() + mock_Disk.return_value.__enter__.return_value = disk + bootloader_config = Mock() + bootloader_config.get_boot_cmdline = Mock( + return_value='boot_cmdline' + ) + mock_create_boot_loader_config.return_value.__enter__.return_value = \ + bootloader_config + filesystem = Mock() + mock_fs.return_value.__enter__.return_value = filesystem + self.disk_builder.volume_manager_name = None + self.disk_builder.mdraid = 'mirroring' + self.disk_builder.integrity = True + self.disk_builder.luks = 'secret' + disk.public_partition_id_map = self.id_map + + with patch('builtins.open'): + self.disk_builder.create_disk() + + disk.create_root_raid_partition.assert_called_once_with( + 'all_free', 0 + ) + raid_root.create_degraded_raid.assert_called_once_with( + raid_level='mirroring' + ) + raid_root.create_raid_config.assert_called_once_with( + 'boot_dir/etc/mdadm.conf' + ) + assert disk.public_partition_id_map == { + 'kiwi_RaidPart': 1, 'kiwi_RootPart': 1, 'kiwi_BootPart': 1, + 'kiwi_RaidDev': '/dev/md0' + } + + @patch('os.path.exists') + @patch('kiwi.builder.disk.RaidDevice') + @patch('kiwi.builder.disk.Disk') + @patch('kiwi.builder.disk.create_boot_loader_config') + @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_on_luks_root( + self, mock_grub_dir, mock_command, mock_fs, + mock_create_boot_loader_config, mock_Disk, mock_RaidDevice, + mock_os_path_exists + ): + mock_os_path_exists.return_value = True + raid_root = Mock() + raid_root.get_device.return_value = MappedDevice( + '/dev/md0', Mock() + ) + mock_RaidDevice.return_value.__enter__.return_value = raid_root + disk = self._get_disk_instance() + mock_Disk.return_value.__enter__.return_value = disk + bootloader_config = Mock() + bootloader_config.get_boot_cmdline = Mock( + return_value='boot_cmdline' + ) + mock_create_boot_loader_config.return_value.__enter__.return_value = \ + bootloader_config + filesystem = Mock() + mock_fs.return_value.__enter__.return_value = filesystem + self.disk_builder.volume_manager_name = None + self.disk_builder.mdraid = 'mirroring' + self.disk_builder.integrity = False + self.disk_builder.luks = 'secret' + disk.public_partition_id_map = self.id_map + + with patch('builtins.open'): + self.disk_builder.create_disk() + + disk.create_root_raid_partition.assert_called_once_with( + 'all_free', 0 + ) + raid_root.create_degraded_raid.assert_called_once_with( + raid_level='mirroring' + ) + raid_root.create_raid_config.assert_called_once_with( + 'boot_dir/etc/mdadm.conf' + ) + assert disk.public_partition_id_map == { + 'kiwi_RaidPart': 1, 'kiwi_RootPart': 1, 'kiwi_BootPart': 1, + 'kiwi_RaidDev': '/dev/md0' + } + + @patch('os.path.exists') + @patch('kiwi.builder.disk.RaidDevice') @patch('kiwi.builder.disk.Disk') @patch('kiwi.builder.disk.create_boot_loader_config') @patch('kiwi.builder.disk.FileSystem.new') @@ -1100,8 +1267,15 @@ def test_create_disk_standard_root_secure_boot( @patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name') def test_create_disk_mdraid_root( self, mock_grub_dir, mock_command, mock_fs, - mock_create_boot_loader_config, mock_Disk + mock_create_boot_loader_config, mock_Disk, mock_RaidDevice, + mock_os_path_exists ): + mock_os_path_exists.return_value = True + raid_root = Mock() + raid_root.get_device.return_value = MappedDevice( + '/dev/md0', Mock() + ) + mock_RaidDevice.return_value.__enter__.return_value = raid_root disk = self._get_disk_instance() mock_Disk.return_value.__enter__.return_value = disk bootloader_config = Mock() @@ -1114,6 +1288,8 @@ def test_create_disk_mdraid_root( mock_fs.return_value.__enter__.return_value = filesystem self.disk_builder.volume_manager_name = None self.disk_builder.mdraid = 'mirroring' + self.disk_builder.integrity = False + self.disk_builder.luks = None disk.public_partition_id_map = self.id_map with patch('builtins.open'): @@ -1122,10 +1298,10 @@ def test_create_disk_mdraid_root( disk.create_root_raid_partition.assert_called_once_with( 'all_free', 0 ) - self.raid_root.create_degraded_raid.assert_called_once_with( + raid_root.create_degraded_raid.assert_called_once_with( raid_level='mirroring' ) - self.raid_root.create_raid_config.assert_called_once_with( + raid_root.create_raid_config.assert_called_once_with( 'boot_dir/etc/mdadm.conf' ) assert disk.public_partition_id_map == { @@ -1133,6 +1309,7 @@ def test_create_disk_mdraid_root( 'kiwi_RaidDev': '/dev/md0' } + @patch('kiwi.builder.disk.LuksDevice') @patch('kiwi.builder.disk.Disk') @patch('kiwi.builder.disk.create_boot_loader_config') @patch('kiwi.builder.disk.FileSystem.new') @@ -1140,8 +1317,11 @@ def test_create_disk_mdraid_root( @patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name') def test_create_disk_luks_root( self, mock_grub_dir, mock_command, mock_fs, - mock_create_boot_loader_config, mock_Disk + mock_create_boot_loader_config, mock_Disk, + mock_LuksDevice ): + luks = Mock() + mock_LuksDevice.return_value.__enter__.return_value = luks disk = self._get_disk_instance() mock_Disk.return_value.__enter__.return_value = disk bootloader_config = Mock() @@ -1164,13 +1344,13 @@ def test_create_disk_luks_root( with patch('builtins.open'): self.disk_builder.create_disk() - self.luks_root.create_crypto_luks.assert_called_once_with( + luks.create_crypto_luks.assert_called_once_with( passphrase='passphrase', osname=None, options=[], keyfile='/root/.root.keyfile', randomize=True, root_dir='root_dir' ) - self.luks_root.create_crypttab.assert_called_once_with( + luks.create_crypttab.assert_called_once_with( 'root_dir/etc/crypttab' ) assert self.boot_image_task.include_file.call_args_list == [ @@ -1183,6 +1363,7 @@ def test_create_disk_luks_root( config_file='root_dir/etc/dracut.conf.d/99-luks-boot.conf' ) + @patch('kiwi.builder.disk.LuksDevice') @patch('kiwi.builder.disk.Disk') @patch('kiwi.builder.disk.create_boot_loader_config') @patch('kiwi.builder.disk.FileSystem.new') @@ -1191,8 +1372,10 @@ def test_create_disk_luks_root( @patch('kiwi.builder.disk.BootLoaderInstall.new') def test_create_disk_luks_root_with_disk_password( self, mock_BootLoaderInstall, mock_grub_dir, mock_command, mock_fs, - mock_create_boot_loader_config, mock_Disk + mock_create_boot_loader_config, mock_Disk, mock_LuksDevice ): + luks = Mock() + mock_LuksDevice.return_value.__enter__.return_value = luks disk = self._get_disk_instance() mock_Disk.return_value.__enter__.return_value = disk bootloader_config = Mock() @@ -1218,13 +1401,13 @@ def test_create_disk_luks_root_with_disk_password( with patch('builtins.open'): self.disk_builder.create_disk() - self.luks_root.create_crypto_luks.assert_called_once_with( + luks.create_crypto_luks.assert_called_once_with( passphrase='passphrase', osname=None, options=[], keyfile='/root/.root.keyfile', randomize=True, root_dir='root_dir' ) - self.luks_root.create_crypttab.assert_called_once_with( + luks.create_crypttab.assert_called_once_with( 'root_dir/etc/crypttab' ) assert self.boot_image_task.include_file.call_args_list == [ @@ -1678,3 +1861,10 @@ def _get_disk_instance(self) -> Mock: disk.storage_provider = provider disk.partitioner = partitioner return disk + + def _get_integrity_instance(self) -> Mock: + integrity_root = Mock() + integrity_root.get_device.return_value = MappedDevice( + '/dev/integrityRoot', Mock() + ) + return integrity_root diff --git a/test/unit/storage/integrity_device_test.py b/test/unit/storage/integrity_device_test.py index 489d64d05c9..30b42766378 100644 --- a/test/unit/storage/integrity_device_test.py +++ b/test/unit/storage/integrity_device_test.py @@ -1,6 +1,9 @@ +import logging import io from textwrap import dedent -from pytest import raises +from pytest import ( + raises, fixture +) from mock import ( patch, Mock, call, MagicMock ) @@ -15,6 +18,10 @@ class TestIntegrityDevice: + @fixture(autouse=True) + def inject_fixtures(self, caplog): + self._caplog = caplog + @patch('os.path.getsize') def setup(self, mock_os_path_getsize): mock_os_path_getsize.return_value = 42 @@ -222,11 +229,12 @@ def test_create_integritytab_with_keyfile(self, mock_BlockID): @patch('kiwi.storage.integrity_device.Command.run') @patch('kiwi.storage.integrity_device.log.warning') def test_destructor(self, mock_log_warn, mock_Command_run): - self.integrity.integrity_device = '/dev/mapper/integrityRoot' mock_Command_run.side_effect = Exception - self.integrity.__del__() + with self._caplog.at_level(logging.ERROR): + with IntegrityDevice( + Mock(), defaults.INTEGRITY_ALGORITHM + ) as integrity: + integrity.integrity_device = '/dev/mapper/integrityRoot' mock_Command_run.assert_called_once_with( ['integritysetup', 'close', 'integrityRoot'] ) - assert mock_log_warn.called - self.integrity.integrity_device = None diff --git a/test/unit/storage/luks_device_test.py b/test/unit/storage/luks_device_test.py index bff2f32898a..82742affcc4 100644 --- a/test/unit/storage/luks_device_test.py +++ b/test/unit/storage/luks_device_test.py @@ -1,14 +1,21 @@ +import logging import io from mock import ( patch, call, MagicMock, Mock ) -from pytest import raises +from pytest import ( + raises, fixture +) from kiwi.exceptions import KiwiLuksSetupError from kiwi.storage.luks_device import LuksDevice class TestLuksDevice: + @fixture(autouse=True) + def inject_fixtures(self, caplog): + self._caplog = caplog + def setup(self): storage_device = Mock() storage_device.get_byte_size = Mock( @@ -175,12 +182,11 @@ def test_is_loop(self): @patch('kiwi.storage.luks_device.Command.run') @patch('kiwi.storage.luks_device.log.warning') - def test_destructor(self, mock_log_warn, mock_command): - self.luks.luks_device = '/dev/mapper/luksRoot' + def test_context_manager_exit(self, mock_log_warn, mock_command): mock_command.side_effect = Exception - self.luks.__del__() + with self._caplog.at_level(logging.ERROR): + with LuksDevice(Mock()) as luks: + luks.luks_device = '/dev/mapper/luksRoot' mock_command.assert_called_once_with( ['cryptsetup', 'luksClose', 'luksRoot'] ) - assert mock_log_warn.called - self.luks.luks_device = None diff --git a/test/unit/storage/raid_device_test.py b/test/unit/storage/raid_device_test.py index 221d65bb101..6045e016f26 100644 --- a/test/unit/storage/raid_device_test.py +++ b/test/unit/storage/raid_device_test.py @@ -1,7 +1,10 @@ +import logging from mock import ( patch, Mock, mock_open ) -from pytest import raises +from pytest import ( + raises, fixture +) from kiwi.storage.raid_device import RaidDevice @@ -9,6 +12,10 @@ class TestRaidDevice: + @fixture(autouse=True) + def inject_fixtures(self, caplog): + self._caplog = caplog + def setup(self): storage_device = Mock() storage_device.get_device = Mock( @@ -78,12 +85,11 @@ def test_is_loop(self): @patch('kiwi.storage.raid_device.Command.run') @patch('kiwi.storage.raid_device.log.warning') - def test_destructor(self, mock_log_warn, mock_command): - self.raid.raid_device = '/dev/md0' + def test_context_manager_exit(self, mock_log_warn, mock_command): mock_command.side_effect = Exception - self.raid.__del__() + with self._caplog.at_level(logging.ERROR): + with RaidDevice(Mock()) as raid: + raid.raid_device = '/dev/md0' mock_command.assert_called_once_with( ['mdadm', '--stop', '/dev/md0'] ) - assert mock_log_warn.called - self.raid.raid_device = None