diff --git a/kiwi/bootloader/config/base.py b/kiwi/bootloader/config/base.py
index c36089cf9c8..33078ccc32b 100644
--- a/kiwi/bootloader/config/base.py
+++ b/kiwi/bootloader/config/base.py
@@ -60,6 +60,9 @@ def __init__(self, xml_state, root_dir, boot_dir=None, custom_args={}):
         self.root_filesystem_is_overlay = xml_state.build_type.get_overlayroot()
         self.post_init(custom_args)
 
+    def __enter__(self):
+        return self
+
     def post_init(self, custom_args):
         """
         Post initialization method
@@ -658,8 +661,7 @@ def _get_location(self, device, persistency_type=''):
             'node': f'/dev/disk/{persistency_type}/{location}'
         }
 
-    def __del__(self):
-        log.info('Cleaning up %s instance', type(self).__name__)
+    def __exit__(self, exc_type, exc_value, traceback):
         for volume_mount in reversed(self.volumes_mount):
             volume_mount.umount()
         if self.device_mount:
diff --git a/kiwi/builder/disk.py b/kiwi/builder/disk.py
index 5c6fdd7f8e9..4a269a7dc2c 100644
--- a/kiwi/builder/disk.py
+++ b/kiwi/builder/disk.py
@@ -831,10 +831,10 @@ def _build_main_system(
 
         # write bootloader meta data to system image
         if self.bootloader != 'custom':
-            bootloader_config = self._bootloader_instance(disk)
-            self._write_bootloader_meta_data_to_system_image(
-                device_map, disk, system, bootloader_config
-            )
+            with self._bootloader_instance(disk) as bootloader_config:
+                self._write_bootloader_meta_data_to_system_image(
+                    device_map, disk, system, bootloader_config
+                )
 
         # call edit_boot_config script
         partition_id_map = disk.get_public_partition_id_map()
@@ -884,10 +884,10 @@ def _build_main_system(
 
         # install boot loader
         if self.bootloader != 'custom':
-            bootloader_config = self._bootloader_instance(disk)
-            self._install_bootloader(
-                device_map, disk, system, bootloader_config
-            )
+            with self._bootloader_instance(disk) as bootloader_config:
+                self._install_bootloader(
+                    device_map, disk, system, bootloader_config
+                )
 
         # call edit_boot_install script
         boot_device = device_map['root']
diff --git a/kiwi/builder/install.py b/kiwi/builder/install.py
index 418cedb0479..e9191ffb2fb 100644
--- a/kiwi/builder/install.py
+++ b/kiwi/builder/install.py
@@ -207,57 +207,42 @@ def create_install_iso(self) -> None:
         log.info(
             'Setting up install image bootloader configuration'
         )
-        if self.firmware.efi_mode():
-            # setup bootloader config to boot the ISO via EFI
-            # This also embedds an MBR and the respective BIOS modules
-            # for compat boot. The complete bootloader setup will be
-            # based on grub
-            bootloader_config = BootLoaderConfig.new(
-                self.bootloader, self.xml_state, root_dir=self.root_dir,
-                boot_dir=self.media_dir.name, custom_args={
-                    'grub_directory_name':
-                        Defaults.get_grub_boot_directory_name(self.root_dir),
-                    'grub_load_command':
-                        'configfile'
-                }
+        with self._bootloader_instance() as bootloader_config:
+            if self.firmware.efi_mode():
+                bootloader_config.setup_install_boot_images(
+                    mbrid=self.mbrid,
+                    lookup_path=self.boot_image_task.boot_root_directory
+                )
+
+            IsoToolsBase.setup_media_loader_directory(
+                self.boot_image_task.boot_root_directory,
+                self.media_dir.name,
+                bootloader_config.get_boot_theme()
             )
-            bootloader_config.setup_install_boot_images(
-                mbrid=self.mbrid,
-                lookup_path=self.boot_image_task.boot_root_directory
+            if self.firmware.bios_mode():
+                Iso(self.media_dir.name).setup_isolinux_boot_path()
+            bootloader_config.write_meta_data()
+            bootloader_config.setup_install_image_config(
+                mbrid=self.mbrid
             )
-        else:
-            # setup bootloader config to boot the ISO via isolinux.
-            # This allows for booting on x86 platforms in BIOS mode
-            # only.
-            bootloader_config = BootLoaderConfig.new(
-                'isolinux', self.xml_state, root_dir=self.root_dir,
-                boot_dir=self.media_dir.name
-            )
-        IsoToolsBase.setup_media_loader_directory(
-            self.boot_image_task.boot_root_directory, self.media_dir.name,
-            bootloader_config.get_boot_theme()
-        )
-        if self.firmware.bios_mode():
-            Iso(self.media_dir.name).setup_isolinux_boot_path()
-        bootloader_config.write_meta_data()
-        bootloader_config.setup_install_image_config(
-            mbrid=self.mbrid
-        )
-        bootloader_config.write()
+            bootloader_config.write()
 
-        # create initrd for install image
-        log.info('Creating install image boot image')
-        self._create_iso_install_kernel_and_initrd()
+            # create initrd for install image
+            log.info('Creating install image boot image')
+            self._create_iso_install_kernel_and_initrd()
 
-        # the system image initrd is stored to allow kexec
-        self._copy_system_image_initrd_to_iso_image()
+            # the system image initrd is stored to allow kexec
+            self._copy_system_image_initrd_to_iso_image()
 
-        if self.firmware.efi_mode():
-            efi_loader = Temporary(
-                prefix='efi-loader.', path=self.target_dir
-            ).new_file()
-            bootloader_config._create_embedded_fat_efi_image(efi_loader.name)
-            self.custom_iso_args['meta_data']['efi_loader'] = efi_loader.name
+            if self.firmware.efi_mode():
+                efi_loader = Temporary(
+                    prefix='efi-loader.', path=self.target_dir
+                ).new_file()
+                bootloader_config._create_embedded_fat_efi_image(
+                    efi_loader.name
+                )
+                self.custom_iso_args['meta_data']['efi_loader'] = \
+                    efi_loader.name
 
         # create iso filesystem from media_dir
         log.info('Creating ISO filesystem')
@@ -376,6 +361,30 @@ def create_install_pxe_archive(self) -> None:
         archive.create(self.pxe_dir.name)
         self.boot_image_task.cleanup()
 
+    def _bootloader_instance(self):
+        if self.firmware.efi_mode():
+            # setup bootloader config to boot the ISO via EFI
+            # This also embedds an MBR and the respective BIOS modules
+            # for compat boot. The complete bootloader setup will be
+            # based on grub
+            return BootLoaderConfig.new(
+                self.bootloader, self.xml_state, root_dir=self.root_dir,
+                boot_dir=self.media_dir.name, custom_args={
+                    'grub_directory_name':
+                        Defaults.get_grub_boot_directory_name(self.root_dir),
+                    'grub_load_command':
+                        'configfile'
+                }
+            )
+        else:
+            # setup bootloader config to boot the ISO via isolinux.
+            # This allows for booting on x86 platforms in BIOS mode
+            # only.
+            return BootLoaderConfig.new(
+                'isolinux', self.xml_state, root_dir=self.root_dir,
+                boot_dir=self.media_dir.name
+            )
+
     def _create_pxe_install_kernel_and_initrd(self) -> None:
         kernelname = 'pxeboot.{0}.kernel'.format(self.pxename)
         initrdname = 'pxeboot.{0}.initrd'.format(self.pxename)
diff --git a/kiwi/builder/live.py b/kiwi/builder/live.py
index 9f1abde0584..54abf0914df 100644
--- a/kiwi/builder/live.py
+++ b/kiwi/builder/live.py
@@ -23,6 +23,7 @@
 # project
 from kiwi.utils.temporary import Temporary
 from kiwi.bootloader.config import BootLoaderConfig
+from kiwi.bootloader.config.base import BootLoaderConfigBase
 from kiwi.filesystem import FileSystem
 from kiwi.filesystem.isofs import FileSystemIsoFs
 from kiwi.filesystem.setup import FileSystemSetup
@@ -146,93 +147,80 @@ def create(self) -> Result:
         log.info(
             'Setting up live image bootloader configuration'
         )
-        if self.firmware.efi_mode():
-            # setup bootloader config to boot the ISO via EFI
-            # This also embedds an MBR and the respective BIOS modules
-            # for compat boot. The complete bootloader setup will be
-            # based on grub
-            bootloader_config = BootLoaderConfig.new(
-                self.bootloader, self.xml_state, root_dir=self.root_dir,
-                boot_dir=self.media_dir.name, custom_args={
-                    'grub_directory_name':
-                        Defaults.get_grub_boot_directory_name(self.root_dir),
-                    'grub_load_command':
-                        'configfile'
-                }
+        with self._bootloader_instance() as bootloader_config:
+            if self.firmware.efi_mode():
+                bootloader_config.setup_live_boot_images(
+                    mbrid=self.mbrid, lookup_path=self.root_dir
+                )
+
+            IsoToolsBase.setup_media_loader_directory(
+                self.boot_image.boot_root_directory, self.media_dir.name,
+                bootloader_config.get_boot_theme()
             )
-            bootloader_config.setup_live_boot_images(
-                mbrid=self.mbrid, lookup_path=self.root_dir
+            if self.firmware.bios_mode():
+                Iso(self.media_dir.name).setup_isolinux_boot_path()
+            bootloader_config.write_meta_data()
+            bootloader_config.setup_live_image_config(
+                mbrid=self.mbrid
             )
-        else:
-            # setup bootloader config to boot the ISO via isolinux.
-            # This allows for booting on x86 platforms in BIOS mode
-            # only.
-            bootloader_config = BootLoaderConfig.new(
-                'isolinux', self.xml_state, root_dir=self.root_dir,
-                boot_dir=self.media_dir.name
+            bootloader_config.write()
+
+            # call custom editbootconfig script if present
+            self.system_setup.call_edit_boot_config_script(
+                filesystem='iso:{0}'.format(self.media_dir.name),
+                boot_part_id=1,
+                working_directory=self.root_dir
             )
-        IsoToolsBase.setup_media_loader_directory(
-            self.boot_image.boot_root_directory, self.media_dir.name,
-            bootloader_config.get_boot_theme()
-        )
-        if self.firmware.bios_mode():
-            Iso(self.media_dir.name).setup_isolinux_boot_path()
-        bootloader_config.write_meta_data()
-        bootloader_config.setup_live_image_config(
-            mbrid=self.mbrid
-        )
-        bootloader_config.write()
 
-        # call custom editbootconfig script if present
-        self.system_setup.call_edit_boot_config_script(
-            filesystem='iso:{0}'.format(self.media_dir.name), boot_part_id=1,
-            working_directory=self.root_dir
-        )
+            # prepare dracut initrd call
+            self.boot_image.prepare()
 
-        # prepare dracut initrd call
-        self.boot_image.prepare()
+            # create dracut initrd for live image
+            log.info('Creating live ISO boot image')
+            live_dracut_modules = Defaults.get_live_dracut_modules_from_flag(
+                self.live_type
+            )
+            live_dracut_modules.append('pollcdrom')
+            for dracut_module in live_dracut_modules:
+                self.boot_image.include_module(dracut_module)
+            self.boot_image.omit_module('multipath')
+            self.boot_image.write_system_config_file(
+                config={
+                    'modules': live_dracut_modules,
+                    'omit_modules': ['multipath']
+                },
+                config_file=self.root_dir + '/etc/dracut.conf.d/02-livecd.conf'
+            )
+            self.boot_image.create_initrd(self.mbrid)
+            if self.bootloader == 'systemd_boot':
+                # make sure the initrd name follows the dracut
+                # naming conventions
+                boot_names = self.boot_image.get_boot_names()
+                if self.boot_image.initrd_filename:
+                    Command.run(
+                        [
+                            'mv', self.boot_image.initrd_filename,
+                            self.root_dir + ''.join(
+                                ['/boot/', boot_names.initrd_name]
+                            )
+                        ]
+                    )
 
-        # create dracut initrd for live image
-        log.info('Creating live ISO boot image')
-        live_dracut_modules = Defaults.get_live_dracut_modules_from_flag(
-            self.live_type
-        )
-        live_dracut_modules.append('pollcdrom')
-        for dracut_module in live_dracut_modules:
-            self.boot_image.include_module(dracut_module)
-        self.boot_image.omit_module('multipath')
-        self.boot_image.write_system_config_file(
-            config={
-                'modules': live_dracut_modules,
-                'omit_modules': ['multipath']
-            },
-            config_file=self.root_dir + '/etc/dracut.conf.d/02-livecd.conf'
-        )
-        self.boot_image.create_initrd(self.mbrid)
-        if self.bootloader == 'systemd_boot':
-            # make sure the initrd name follows the dracut naming conventions
-            boot_names = self.boot_image.get_boot_names()
-            if self.boot_image.initrd_filename:
-                Command.run(
-                    [
-                        'mv', self.boot_image.initrd_filename,
-                        self.root_dir + ''.join(
-                            ['/boot/', boot_names.initrd_name]
-                        )
-                    ]
+            # create EFI FAT image
+            if self.firmware.efi_mode():
+                efi_loader = Temporary(
+                    prefix='efi-loader.', path=self.target_dir
+                ).new_file()
+                bootloader_config._create_embedded_fat_efi_image(
+                    efi_loader.name
                 )
-
-        # create EFI FAT image
-        if self.firmware.efi_mode():
-            efi_loader = Temporary(
-                prefix='efi-loader.', path=self.target_dir
-            ).new_file()
-            bootloader_config._create_embedded_fat_efi_image(efi_loader.name)
-            custom_iso_args['meta_data']['efi_loader'] = efi_loader.name
+                custom_iso_args['meta_data']['efi_loader'] = efi_loader.name
 
         # setup kernel file(s) and initrd in ISO boot layout
         if self.bootloader != 'systemd_boot':
-            log.info('Setting up kernel file(s) and boot image in ISO boot layout')
+            log.info(
+                'Setting up kernel file(s) and boot image in ISO boot layout'
+            )
             self._setup_live_iso_kernel_and_initrd()
 
         # calculate size and decide if we need UDF
@@ -359,6 +347,30 @@ def create(self) -> Result:
         )
         return self.result
 
+    def _bootloader_instance(self) -> BootLoaderConfigBase:
+        if self.firmware.efi_mode():
+            # setup bootloader config to boot the ISO via EFI
+            # This also embedds an MBR and the respective BIOS modules
+            # for compat boot. The complete bootloader setup will be
+            # based on grub
+            return BootLoaderConfig.new(
+                self.bootloader, self.xml_state, root_dir=self.root_dir,
+                boot_dir=self.media_dir.name, custom_args={
+                    'grub_directory_name':
+                        Defaults.get_grub_boot_directory_name(self.root_dir),
+                    'grub_load_command':
+                        'configfile'
+                }
+            )
+        else:
+            # setup bootloader config to boot the ISO via isolinux.
+            # This allows for booting on x86 platforms in BIOS mode
+            # only.
+            return BootLoaderConfig.new(
+                'isolinux', self.xml_state, root_dir=self.root_dir,
+                boot_dir=self.media_dir.name
+            )
+
     def _setup_live_iso_kernel_and_initrd(self) -> None:
         """
         Copy kernel and initrd from the root tree into the iso boot structure
diff --git a/test/unit/bootloader/config/base_test.py b/test/unit/bootloader/config/base_test.py
index f81847b5b5e..35f4db4f620 100644
--- a/test/unit/bootloader/config/base_test.py
+++ b/test/unit/bootloader/config/base_test.py
@@ -390,38 +390,38 @@ def mount_managers_effect(**args):
             return mount_managers.pop()
 
         mock_MountManager.side_effect = mount_managers_effect
-        self.bootloader.root_filesystem_is_overlay = True
-        self.bootloader._mount_system(
-            'rootdev', 'bootdev', 'efidev', {
-                'boot/grub2': {
-                    'volume_options': 'subvol=@/boot/grub2',
-                    'volume_device': 'device'
-                }
-            }, root_volume_name='root'
-        )
-        assert mock_MountManager.call_args_list == [
-            call(device='rootdev'),
-            call(device='bootdev', mountpoint='root_mount_point/boot'),
-            call(device='efidev', mountpoint='root_mount_point/boot/efi'),
-            call(device='device', mountpoint='root_mount_point/boot/grub2'),
-            call(device='/tmp', mountpoint='root_mount_point/tmp'),
-            call(device='/dev', mountpoint='root_mount_point/dev'),
-            call(device='/proc', mountpoint='root_mount_point/proc'),
-            call(device='/sys', mountpoint='root_mount_point/sys')
-        ]
-        root_mount.mount.assert_called_once_with(
-            options=['subvol=root']
-        )
-        boot_mount.mount.assert_called_once_with()
-        efi_mount.mount.assert_called_once_with()
-        volume_mount.mount.assert_called_once_with(
-            options=['subvol=@/boot/grub2']
-        )
-        proc_mount.bind_mount.assert_called_once_with()
-        sys_mount.bind_mount.assert_called_once_with()
-        dev_mount.bind_mount.assert_called_once_with()
 
-        del self.bootloader
+        with BootLoaderConfigBase(self.state, 'root_dir') as bootloader:
+            bootloader.root_filesystem_is_overlay = True
+            bootloader._mount_system(
+                'rootdev', 'bootdev', 'efidev', {
+                    'boot/grub2': {
+                        'volume_options': 'subvol=@/boot/grub2',
+                        'volume_device': 'device'
+                    }
+                }, root_volume_name='root'
+            )
+            assert mock_MountManager.call_args_list == [
+                call(device='rootdev'),
+                call(device='bootdev', mountpoint='root_mount_point/boot'),
+                call(device='efidev', mountpoint='root_mount_point/boot/efi'),
+                call(device='device', mountpoint='root_mount_point/boot/grub2'),
+                call(device='/tmp', mountpoint='root_mount_point/tmp'),
+                call(device='/dev', mountpoint='root_mount_point/dev'),
+                call(device='/proc', mountpoint='root_mount_point/proc'),
+                call(device='/sys', mountpoint='root_mount_point/sys')
+            ]
+            root_mount.mount.assert_called_once_with(
+                options=['subvol=root']
+            )
+            boot_mount.mount.assert_called_once_with()
+            efi_mount.mount.assert_called_once_with()
+            volume_mount.mount.assert_called_once_with(
+                options=['subvol=@/boot/grub2']
+            )
+            proc_mount.bind_mount.assert_called_once_with()
+            sys_mount.bind_mount.assert_called_once_with()
+            dev_mount.bind_mount.assert_called_once_with()
 
         volume_mount.umount.assert_called_once_with()
         tmp_mount.umount.assert_called_once_with()
diff --git a/test/unit/builder/disk_test.py b/test/unit/builder/disk_test.py
index 9aeb17b4941..2868258be02 100644
--- a/test/unit/builder/disk_test.py
+++ b/test/unit/builder/disk_test.py
@@ -134,14 +134,6 @@ def side_effect(filename):
         kiwi.builder.disk.BootLoaderInstall.new = MagicMock(
             return_value=self.bootloader_install
         )
-        self.bootloader_config = Mock()
-        self.bootloader_config.use_disk_password = True
-        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
         )
@@ -286,6 +278,7 @@ def test_create_install_mediai_custom_boot(
             {'signing_keys': ['key_file_a', 'key_file_b']}
         )
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @patch('kiwi.builder.disk.LoopDevice')
     @patch('kiwi.builder.disk.FileSystem.new')
     @patch('random.randrange')
@@ -295,8 +288,15 @@ def test_create_install_mediai_custom_boot(
     @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_LoopDevice
+        mock_command, mock_rand, mock_fs, mock_LoopDevice,
+        mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         loop_provider = Mock()
         mock_LoopDevice.return_value.__enter__.return_value = loop_provider
         mock_path.return_value = True
@@ -340,15 +340,15 @@ def test_create_disk_standard_root_with_kiwi_initrd(
             'all_free', 0
         )
         self.disk.map_partitions.assert_called_once_with()
-        self.bootloader_config.setup_disk_boot_images.assert_called_once_with(
+        bootloader_config.setup_disk_boot_images.assert_called_once_with(
             '0815'
         )
-        self.bootloader_config.write_meta_data.assert_called_once_with(
+        bootloader_config.write_meta_data.assert_called_once_with(
             root_device='/dev/readonly-root-device',
             write_device='/dev/root-device',
             boot_options=''
         )
-        self.bootloader_config.setup_disk_image_config.assert_called_once_with(
+        bootloader_config.setup_disk_image_config.assert_called_once_with(
             boot_options={
                 'boot_device': '/dev/boot-device',
                 'root_device': '/dev/readonly-root-device',
@@ -422,6 +422,7 @@ def test_create_disk_standard_root_with_kiwi_initrd(
             'target_dir'
         )
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @patch('kiwi.builder.disk.VolumeManager.new')
     @patch('kiwi.builder.disk.FileSystem.new')
     @patch('kiwi.builder.disk.Command.run')
@@ -435,8 +436,15 @@ def test_create_disk_standard_root_with_kiwi_initrd(
     def test_create_lvm_disk_standard_root_with_clone(
         self, mock_CloneDevice, mock_Temporary_new_file, mock_ImageSystem,
         mock_SystemSetup, mock_os_path_getsize, mock_path,
-        mock_grub_dir, mock_command, mock_fs, mock_volume_manager
+        mock_grub_dir, mock_command, mock_fs, mock_volume_manager,
+        mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         tempfile = Mock()
         tempfile.name = 'tempfile'
         mock_Temporary_new_file.return_value = tempfile
@@ -488,6 +496,7 @@ def test_create_lvm_disk_standard_root_with_clone(
         volume_manager.\
             umount_volumes.call_args_list[0].assert_called_once_with()
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @patch('kiwi.builder.disk.FileSystem.new')
     @patch('kiwi.builder.disk.Command.run')
     @patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
@@ -500,8 +509,14 @@ def test_create_lvm_disk_standard_root_with_clone(
     def test_create_disk_standard_root_with_clone(
         self, mock_CloneDevice, mock_Temporary_new_file, mock_ImageSystem,
         mock_SystemSetup, mock_os_path_getsize, mock_path,
-        mock_grub_dir, mock_command, mock_fs
+        mock_grub_dir, mock_command, mock_fs, mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         tempfile = Mock()
         tempfile.name = 'tempfile'
         mock_Temporary_new_file.return_value = tempfile
@@ -586,6 +601,7 @@ def test_create_disk_standard_root_with_clone(
             call([self.device_map['rootclone1']])
         ]
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @patch('kiwi.builder.disk.FileSystem.new')
     @patch('kiwi.builder.disk.Command.run')
     @patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
@@ -597,8 +613,14 @@ def test_create_disk_standard_root_with_clone(
     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_grub_dir, mock_command, mock_fs, mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         tempfile = Mock()
         tempfile.name = 'tempfile'
         mock_Temporary_new_file.return_value = tempfile
@@ -637,6 +659,7 @@ def test_create_disk_standard_root_with_dm_integrity(
             call(label='SWAP')
         ]
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @patch('kiwi.builder.disk.LoopDevice')
     @patch('kiwi.builder.disk.FileSystem.new')
     @patch('random.randrange')
@@ -652,8 +675,14 @@ 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,
-        mock_LoopDevice
+        mock_LoopDevice, mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         loop_provider = Mock()
         mock_LoopDevice.return_value.__enter__.return_value = loop_provider
         tempfile = Mock()
@@ -705,15 +734,15 @@ def test_create_disk_standard_root_with_dracut_initrd(
             'all_free', 0
         )
         self.disk.map_partitions.assert_called_once_with()
-        self.bootloader_config.setup_disk_boot_images.assert_called_once_with(
+        bootloader_config.setup_disk_boot_images.assert_called_once_with(
             '0815'
         )
-        self.bootloader_config.write_meta_data.assert_called_once_with(
+        bootloader_config.write_meta_data.assert_called_once_with(
             root_device='/dev/readonly-root-device',
             write_device='/dev/root-device',
             boot_options=''
         )
-        self.bootloader_config.setup_disk_image_config.assert_called_once_with(
+        bootloader_config.setup_disk_image_config.assert_called_once_with(
             boot_options={
                 'boot_device': '/dev/boot-device',
                 'root_device': '/dev/readonly-root-device',
@@ -801,6 +830,7 @@ def test_create_disk_standard_root_with_dracut_initrd(
             '/dev/root-device'
         )
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @patch('kiwi.builder.disk.FileSystem.new')
     @patch('random.randrange')
     @patch('kiwi.builder.disk.Command.run')
@@ -813,7 +843,8 @@ def test_create_disk_standard_root_with_dracut_initrd(
     def test_create_disk_standard_root_with_fixed_rootfs_size(
         self, mock_Temporary_new_file,
         mock_ImageSystem, mock_SystemSetup, mock_os_path_getsize,
-        mock_path, mock_grub_dir, mock_command, mock_rand, mock_fs
+        mock_path, mock_grub_dir, mock_command, mock_rand, mock_fs,
+        mock_BootLoaderConfig
     ):
         self.disk_builder.root_filesystem_embed_verity_metadata = False
         self.disk_builder.root_filesystem_is_overlay = False
@@ -824,6 +855,13 @@ def test_create_disk_standard_root_with_fixed_rootfs_size(
         self.disk_builder.oem_systemsize = 1024
         self.disk_builder.oem_resize = False
 
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
+
         m_open = mock_open()
         with patch('builtins.open', m_open, create=True):
             self.disk_builder.create_disk()
@@ -832,6 +870,7 @@ def test_create_disk_standard_root_with_fixed_rootfs_size(
             'clone:1024:1024', 1
         )
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @patch('kiwi.builder.disk.LoopDevice')
     @patch('kiwi.builder.disk.DeviceProvider')
     @patch('kiwi.builder.disk.FileSystem.new')
@@ -847,8 +886,14 @@ 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,
-        mock_LoopDevice
+        mock_LoopDevice, mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         loop_provider = Mock()
         mock_LoopDevice.return_value.__enter__.return_value = loop_provider
         block_operation = Mock()
@@ -947,11 +992,18 @@ def test_create_disk_standard_root_no_hypervisor_found(
             with raises(KiwiDiskBootImageError):
                 self.disk_builder.create_disk()
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @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
+        self, mock_command, mock_fs, mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         filesystem = Mock()
         mock_fs.return_value.__enter__.return_value = filesystem
         self.disk_builder.volume_manager_name = None
@@ -967,13 +1019,20 @@ def test_create_disk_standard_root_xen_server_boot(
             'root_dir', '/boot/xen.gz'
         )
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @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, mock_grub_dir, mock_command, mock_fs, mock_BootLoaderConfig
     ):
         self.disk_builder.arch = 's390x'
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         filesystem = Mock()
         mock_fs.return_value.__enter__.return_value = filesystem
         self.disk_builder.volume_manager_name = None
@@ -985,14 +1044,21 @@ def test_create_disk_standard_root_s390_boot(
         with patch('builtins.open'):
             self.disk_builder.create_disk()
 
-        self.bootloader_config.write.assert_called_once_with()
+        bootloader_config.write.assert_called_once_with()
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @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
+        self, mock_grub_dir, mock_command, mock_fs, mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         filesystem = Mock()
         mock_fs.return_value.__enter__.return_value = filesystem
         self.disk_builder.volume_manager_name = None
@@ -1002,15 +1068,23 @@ def test_create_disk_standard_root_secure_boot(
         with patch('builtins.open'):
             self.disk_builder.create_disk()
 
-        bootloader = self.bootloader_config
-        bootloader.setup_disk_boot_images.assert_called_once_with('0815')
+        bootloader_config.setup_disk_boot_images.assert_called_once_with(
+            '0815'
+        )
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @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
+        self, mock_grub_dir, mock_command, mock_fs, mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         filesystem = Mock()
         mock_fs.return_value.__enter__.return_value = filesystem
         self.disk_builder.volume_manager_name = None
@@ -1034,12 +1108,19 @@ def test_create_disk_mdraid_root(
             'kiwi_RaidDev': '/dev/md0'
         }
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @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
+        self, mock_grub_dir, mock_command, mock_fs, mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         filesystem = Mock()
         mock_fs.return_value.__enter__.return_value = filesystem
         self.disk_builder.volume_manager_name = None
@@ -1073,13 +1154,22 @@ def test_create_disk_luks_root(
             config_file='root_dir/etc/dracut.conf.d/99-luks-boot.conf'
         )
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @patch('kiwi.builder.disk.FileSystem.new')
     @patch('kiwi.builder.disk.Command.run')
     @patch('kiwi.builder.disk.Defaults.get_grub_boot_directory_name')
     @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
+        self, mock_BootLoaderInstall, mock_grub_dir, mock_command, mock_fs,
+        mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        bootloader_config.use_disk_password = True
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         filesystem = Mock()
         mock_fs.return_value.__enter__.return_value = filesystem
         self.disk_builder.volume_manager_name = None
@@ -1091,9 +1181,6 @@ def test_create_disk_luks_root_with_disk_password(
         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
-        bootloader_config = Mock()
-        bootloader_config.use_disk_password = True
-        self.disk_builder.bootloader_config = bootloader_config
         bootloader = mock_BootLoaderInstall.return_value
 
         with patch('builtins.open'):
@@ -1119,14 +1206,22 @@ def test_create_disk_luks_root_with_disk_password(
         )
         bootloader.set_disk_password.assert_called_once_with('passphrase')
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @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')
     @patch('kiwi.builder.disk.BlockID')
     def test_create_disk_uses_custom_partitions(
-        self, mock_BlockID, mock_exists, mock_grub_dir, mock_command, mock_fs
+        self, mock_BlockID, mock_exists, mock_grub_dir, mock_command, mock_fs,
+        mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         self.fstype_mock_list = [
             'ext3',
             'squashfs',
@@ -1207,6 +1302,7 @@ def get_filesystem():
             call('LABEL=blkid_result /var ext3 defaults 0 0')
         ] in self.disk_builder.fstab.add_entry.call_args_list
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @patch('kiwi.builder.disk.FileSystem.new')
     @patch('kiwi.builder.disk.VolumeManager.new')
     @patch('kiwi.builder.disk.Command.run')
@@ -1215,8 +1311,14 @@ def get_filesystem():
     @patch('os.path.exists')
     def test_create_disk_btrfs_managed_root(
         self, mock_exists, mock_ImageSystem, mock_grub_dir, mock_command,
-        mock_volume_manager, mock_fs
+        mock_volume_manager, mock_fs, mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         mock_exists.return_value = True
         volume_manager = Mock()
         volume_manager.get_device = Mock(
@@ -1243,6 +1345,7 @@ def test_create_disk_btrfs_managed_root(
             call('UUID=blkid_result / blkid_result_fs ro,defaults,subvol=@ 0 0')
         ] in self.disk_builder.fstab.add_entry.call_args_list
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @patch('kiwi.builder.disk.FileSystem.new')
     @patch('kiwi.builder.disk.VolumeManager.new')
     @patch('kiwi.builder.disk.Command.run')
@@ -1251,8 +1354,14 @@ def test_create_disk_btrfs_managed_root(
     @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_volume_manager, mock_fs, mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         mock_exists.return_value = True
         volume_manager = Mock()
         volume_manager.get_device = Mock(
@@ -1298,12 +1407,19 @@ def test_create_disk_volume_managed_root(
             self.disk_builder.fstab
         )
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @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
+        self, mock_grub_dir, mock_command, mock_fs, mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         filesystem = Mock()
         mock_fs.return_value.__enter__.return_value = filesystem
         self.disk_builder.volume_manager_name = None
@@ -1315,12 +1431,19 @@ def test_create_disk_hybrid_gpt_requested(
 
         self.disk.create_hybrid_mbr.assert_called_once_with()
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @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
+        self, mock_grub_dir, mock_command, mock_fs, mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         filesystem = Mock()
         mock_fs.return_value.__enter__.return_value = filesystem
         self.disk_builder.volume_manager_name = None
@@ -1332,12 +1455,19 @@ def test_create_disk_force_mbr_requested(
 
         self.disk.create_mbr.assert_called_once_with()
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @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_custom_start_sector_requested(
-        self, mock_grub_dir, mock_command, mock_fs
+        self, mock_grub_dir, mock_command, mock_fs, mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         filesystem = Mock()
         mock_fs.return_value.__enter__.return_value = filesystem
         self.disk_builder.volume_manager_name = None
@@ -1371,12 +1501,19 @@ def test_create(self):
         append_unpartitioned.assert_called_once_with()
         create_disk_format.assert_called_once_with(result)
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @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
+        self, mock_grub_dir, mock_command, mock_fs, mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        bootloader_config.get_boot_cmdline = Mock(
+            return_value='boot_cmdline'
+        )
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         filesystem = Mock()
         mock_fs.return_value.__enter__.return_value = filesystem
         self.disk_builder.volume_manager_name = None
diff --git a/test/unit/builder/install_test.py b/test/unit/builder/install_test.py
index 0dcae38c154..801b64eeb24 100644
--- a/test/unit/builder/install_test.py
+++ b/test/unit/builder/install_test.py
@@ -37,7 +37,6 @@ def setup(self):
             return_value=self.mbrid
         )
         kiwi.builder.install.Path = mock.Mock()
-        kiwi.builder.install.BootLoaderConfig.new = mock.Mock()
         self.checksum = mock.Mock()
         kiwi.builder.install.Checksum = mock.Mock(
             return_value=self.checksum
@@ -148,7 +147,8 @@ def side_effect(prefix, path):
             return tmp_names.pop()
 
         bootloader_config = mock.Mock()
-        mock_BootLoaderConfig.return_value = bootloader_config
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         mock_Temporary.side_effect = side_effect
 
         self.firmware.bios_mode.return_value = False
@@ -274,11 +274,13 @@ def side_effect(prefix, path):
         )
         bootloader_config._create_embedded_fat_efi_image.assert_not_called()
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @patch('kiwi.builder.install.IsoToolsBase.setup_media_loader_directory')
     @patch('kiwi.builder.install.Temporary')
     @patch('kiwi.builder.install.Command.run')
     def test_create_install_iso_no_kernel_found(
-        self, mock_command, mock_Temporary, mock_setup_media_loader_directory
+        self, mock_command, mock_Temporary, mock_setup_media_loader_directory,
+        mock_BootLoaderConfig
     ):
         self.firmware.bios_mode.return_value = False
         self.kernel.get_kernel.return_value = False
@@ -286,11 +288,13 @@ def test_create_install_iso_no_kernel_found(
             with raises(KiwiInstallBootImageError):
                 self.install_image.create_install_iso()
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @patch('kiwi.builder.install.IsoToolsBase.setup_media_loader_directory')
     @patch('kiwi.builder.install.Temporary')
     @patch('kiwi.builder.install.Command.run')
     def test_create_install_iso_no_hypervisor_found(
-        self, mock_command, mock_Temporary, mock_setup_media_loader_directory
+        self, mock_command, mock_Temporary, mock_setup_media_loader_directory,
+        mock_BootLoaderConfig
     ):
         self.firmware.bios_mode.return_value = False
         self.kernel.get_xen_hypervisor.return_value = False
diff --git a/test/unit/builder/live_test.py b/test/unit/builder/live_test.py
index 9bb3c93b95f..43a0b4660c0 100644
--- a/test/unit/builder/live_test.py
+++ b/test/unit/builder/live_test.py
@@ -34,11 +34,6 @@ def setup(self):
             return_value=self.filesystem_setup
         )
 
-        self.bootloader = Mock()
-        kiwi.builder.live.BootLoaderConfig.new = Mock(
-            return_value=self.bootloader
-        )
-
         self.boot_image_task = Mock()
         self.boot_image_task.boot_root_directory = 'initrd_dir'
         self.boot_image_task.initrd_filename = 'initrd'
@@ -128,6 +123,7 @@ def test_init_for_ix86_platform(self):
         )
         assert live_image.arch == 'ix86'
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @patch('kiwi.builder.live.LoopDevice')
     @patch('kiwi.builder.live.Command.run')
     @patch('kiwi.builder.live.DeviceProvider')
@@ -146,7 +142,7 @@ def test_create_overlay_structure_boot_on_systemd_boot(
         self, mock_chmod, mock_exists, mock_grub_dir, mock_size,
         mock_filesystem, mock_isofs, mock_Iso, mock_tag, mock_shutil,
         mock_Temporary, mock_setup_media_loader_directory, mock_DeviceProvider,
-        mock_Command_run, mock_LoopDevice
+        mock_Command_run, mock_LoopDevice, mock_BootLoaderConfig
     ):
         boot_names = Mock()
         boot_names.initrd_name = 'dracut_initrd_name'
@@ -165,6 +161,7 @@ def test_create_overlay_structure_boot_on_systemd_boot(
             ['mv', 'kiwi_used_initrd_name', 'root_dir/boot/dracut_initrd_name']
         )
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @patch('kiwi.builder.live.LoopDevice')
     @patch('kiwi.builder.live.DeviceProvider')
     @patch('kiwi.builder.live.IsoToolsBase.setup_media_loader_directory')
@@ -182,8 +179,11 @@ def test_create_overlay_structure_boot_on_grub(
         self, mock_chmod, mock_exists, mock_grub_dir, mock_size,
         mock_filesystem, mock_isofs, mock_Iso, mock_tag, mock_shutil,
         mock_Temporary, mock_setup_media_loader_directory, mock_DeviceProvider,
-        mock_LoopDevice
+        mock_LoopDevice, mock_BootLoaderConfig
     ):
+        bootloader_config = Mock()
+        mock_BootLoaderConfig.return_value.__enter__.return_value = \
+            bootloader_config
         loop_provider = Mock()
         mock_LoopDevice.return_value.__enter__.return_value = loop_provider
         mock_exists.return_value = True
@@ -283,18 +283,18 @@ def side_effect():
                 'grub_load_command': 'configfile'
             }
         )
-        self.bootloader.setup_live_boot_images.assert_called_once_with(
+        bootloader_config.setup_live_boot_images.assert_called_once_with(
             lookup_path='root_dir', mbrid=self.mbrid
         )
         mock_setup_media_loader_directory.assert_called_once_with(
             'initrd_dir', 'temp_media_dir',
-            self.bootloader.get_boot_theme.return_value
+            bootloader_config.get_boot_theme.return_value
         )
-        self.bootloader.write_meta_data.assert_called_once_with()
-        self.bootloader.setup_live_image_config.assert_called_once_with(
+        bootloader_config.write_meta_data.assert_called_once_with()
+        bootloader_config.setup_live_image_config.assert_called_once_with(
             mbrid=self.mbrid
         )
-        self.bootloader.write.assert_called_once_with()
+        bootloader_config.write.assert_called_once_with()
 
         self.boot_image_task.prepare.assert_called_once_with()
         self.boot_image_task.create_initrd.assert_called_once_with(
@@ -379,12 +379,13 @@ def side_effect():
             boot_dir='temp_media_dir'
         )
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @patch('kiwi.builder.live.IsoToolsBase.setup_media_loader_directory')
     @patch('kiwi.builder.live.Temporary')
     @patch('kiwi.builder.live.shutil')
     def test_create_no_kernel_found(
-        self, mock_shutil, mock_Temporary,
-        mock_setup_media_loader_directory
+        self, mock_shutil, mock_Temporary, mock_setup_media_loader_directory,
+        mock_BootLoaderConfig
     ):
         self.firmware.bios_mode.return_value = False
         mock_Temporary.return_value.new_dir.return_value.name = 'tmpdir'
@@ -392,12 +393,13 @@ def test_create_no_kernel_found(
         with raises(KiwiLiveBootImageError):
             self.live_image.create()
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @patch('kiwi.builder.live.IsoToolsBase.setup_media_loader_directory')
     @patch('kiwi.builder.live.Temporary')
     @patch('kiwi.builder.live.shutil')
     def test_create_no_hypervisor_found(
-        self, mock_shutil, mock_Temporary,
-        mock_setup_media_loader_directory
+        self, mock_shutil, mock_Temporary, mock_setup_media_loader_directory,
+        mock_BootLoaderConfig
     ):
         self.firmware.bios_mode.return_value = False
         mock_Temporary.return_value.new_dir.return_value.name = 'tmpdir'
@@ -405,13 +407,15 @@ def test_create_no_hypervisor_found(
         with raises(KiwiLiveBootImageError):
             self.live_image.create()
 
+    @patch('kiwi.builder.disk.BootLoaderConfig.new')
     @patch('kiwi.builder.live.IsoToolsBase.setup_media_loader_directory')
     @patch('kiwi.builder.live.Temporary')
     @patch('kiwi.builder.live.shutil')
     @patch('os.path.exists')
     def test_create_no_initrd_found(
         self, mock_exists, mock_shutil, mock_Temporary,
-        mock_setup_media_loader_directory
+        mock_setup_media_loader_directory,
+        mock_BootLoaderConfig
     ):
         self.firmware.bios_mode.return_value = False
         mock_Temporary.return_value.new_dir.return_value.name = 'tmpdir'