diff --git a/test/py/tests/test_android/test_abootimg.py b/test/py/tests/test_android/test_abootimg.py
index c31fb46..2aadb69 100644
--- a/test/py/tests/test_android/test_abootimg.py
+++ b/test/py/tests/test_android/test_abootimg.py
@@ -232,38 +232,37 @@
 def test_abootimgv4(abootimgv4_disk_image_vboot, abootimgv4_disk_image_boot, ubman):
     """Test the 'abootimg' command with boot image header v4."""
 
-    cons = ubman
-    cons.log.action('Loading disk image to RAM...')
-    cons.run_command('setenv loadaddr 0x%x' % (loadaddr))
-    cons.run_command('setenv vloadaddr 0x%x' % (vloadaddr))
-    cons.run_command('host load hostfs - 0x%x %s' % (vloadaddr,
+    ubman.log.action('Loading disk image to RAM...')
+    ubman.run_command('setenv loadaddr 0x%x' % (loadaddr))
+    ubman.run_command('setenv vloadaddr 0x%x' % (vloadaddr))
+    ubman.run_command('host load hostfs - 0x%x %s' % (vloadaddr,
 	abootimgv4_disk_image_vboot.path))
-    cons.run_command('host load hostfs - 0x%x %s' % (loadaddr,
+    ubman.run_command('host load hostfs - 0x%x %s' % (loadaddr,
         abootimgv4_disk_image_boot.path))
-    cons.run_command('abootimg addr 0x%x 0x%x' % (loadaddr, vloadaddr))
-    cons.log.action('Testing \'abootimg get ver\'...')
-    response = cons.run_command('abootimg get ver')
+    ubman.run_command('abootimg addr 0x%x 0x%x' % (loadaddr, vloadaddr))
+    ubman.log.action('Testing \'abootimg get ver\'...')
+    response = ubman.run_command('abootimg get ver')
     assert response == "4"
-    cons.run_command('abootimg get ver v')
-    response = cons.run_command('env print v')
+    ubman.run_command('abootimg get ver v')
+    response = ubman.run_command('env print v')
     assert response == 'v=4'
 
-    cons.log.action('Testing \'abootimg get recovery_dtbo\'...')
-    response = cons.run_command('abootimg get recovery_dtbo a')
+    ubman.log.action('Testing \'abootimg get recovery_dtbo\'...')
+    response = ubman.run_command('abootimg get recovery_dtbo a')
     assert response == 'Error: header version must be >= 1 and <= 2 to get dtbo'
 
-    cons.log.action('Testing \'abootimg get dtb_load_addr\'...')
-    cons.run_command('abootimg get dtb_load_addr a')
-    response = cons.run_command('env print a')
+    ubman.log.action('Testing \'abootimg get dtb_load_addr\'...')
+    ubman.run_command('abootimg get dtb_load_addr a')
+    response = ubman.run_command('env print a')
     assert response == 'a=11f00000'
 
-    cons.log.action('Testing \'abootimg get dtb --index\'...')
-    cons.run_command('abootimg get dtb --index=1 dtb2_start')
-    response = cons.run_command('env print dtb2_start')
+    ubman.log.action('Testing \'abootimg get dtb --index\'...')
+    ubman.run_command('abootimg get dtb --index=1 dtb2_start')
+    response = ubman.run_command('env print dtb2_start')
     correct_str = "dtb2_start=%x" % (dtb2_addr)
     assert response == correct_str
 
-    cons.run_command('fdt addr $dtb2_start')
-    cons.run_command('fdt get value v / model')
-    response = cons.run_command('env print v')
+    ubman.run_command('fdt addr $dtb2_start')
+    ubman.run_command('fdt get value v / model')
+    response = ubman.run_command('env print v')
     assert response == 'v=x2'
diff --git a/test/py/tests/test_efi_fit.py b/test/py/tests/test_efi_fit.py
index e7d523a..5f352e7 100644
--- a/test/py/tests/test_efi_fit.py
+++ b/test/py/tests/test_efi_fit.py
@@ -148,13 +148,13 @@
         at the beginning of this file.
         """
 
-        init_usb = cons.config.env.get('env__net_uses_usb', False)
+        init_usb = ubman.config.env.get('env__net_uses_usb', False)
         if init_usb:
-            cons.run_command('usb start')
+            ubman.run_command('usb start')
 
-        init_pci = cons.config.env.get('env__net_uses_pci', False)
+        init_pci = ubman.config.env.get('env__net_uses_pci', False)
         if init_pci:
-            cons.run_command('pci enum')
+            ubman.run_command('pci enum')
 
     def net_dhcp():
         """Execute the dhcp command.
@@ -163,18 +163,18 @@
         comment at the beginning of this file.
         """
 
-        has_dhcp = cons.config.buildconfig.get('config_cmd_dhcp', 'n') == 'y'
+        has_dhcp = ubman.config.buildconfig.get('config_cmd_dhcp', 'n') == 'y'
         if not has_dhcp:
-            cons.log.warning('CONFIG_CMD_DHCP != y: Skipping DHCP network setup')
+            ubman.log.warning('CONFIG_CMD_DHCP != y: Skipping DHCP network setup')
             return False
 
-        test_dhcp = cons.config.env.get('env__net_dhcp_server', False)
+        test_dhcp = ubman.config.env.get('env__net_dhcp_server', False)
         if not test_dhcp:
-            cons.log.info('No DHCP server available')
+            ubman.log.info('No DHCP server available')
             return False
 
-        cons.run_command('setenv autoload no')
-        output = cons.run_command('dhcp')
+        ubman.run_command('setenv autoload no')
+        output = ubman.run_command('dhcp')
         assert 'DHCP client bound to address ' in output
         return True
 
@@ -185,18 +185,18 @@
         the beginning of this file.
         """
 
-        has_dhcp = cons.config.buildconfig.get('config_cmd_dhcp', 'n') == 'y'
+        has_dhcp = ubman.config.buildconfig.get('config_cmd_dhcp', 'n') == 'y'
         if not has_dhcp:
-            cons.log.warning('CONFIG_NET != y: Skipping static network setup')
+            ubman.log.warning('CONFIG_NET != y: Skipping static network setup')
             return False
 
-        env_vars = cons.config.env.get('env__net_static_env_vars', None)
+        env_vars = ubman.config.env.get('env__net_static_env_vars', None)
         if not env_vars:
-            cons.log.info('No static network configuration is defined')
+            ubman.log.info('No static network configuration is defined')
             return False
 
         for (var, val) in env_vars:
-            cons.run_command('setenv %s %s' % (var, val))
+            ubman.run_command('setenv %s %s' % (var, val))
         return True
 
     def make_fpath(file_name):
@@ -208,7 +208,7 @@
             The computed file path.
         """
 
-        return os.path.join(cons.config.build_dir, file_name)
+        return os.path.join(ubman.config.build_dir, file_name)
 
     def make_efi(fname, comp):
         """Create an UEFI binary.
@@ -224,11 +224,11 @@
         """
 
         bin_path = make_fpath(fname)
-        utils.run_and_log(cons,
+        utils.run_and_log(ubman,
                           ['cp', make_fpath('lib/efi_loader/helloworld.efi'),
                            bin_path])
         if comp:
-            utils.run_and_log(cons, ['gzip', '-f', bin_path])
+            utils.run_and_log(ubman, ['gzip', '-f', bin_path])
             bin_path += '.gz'
         return bin_path
 
@@ -257,10 +257,10 @@
 
         # Build the test FDT.
         dtb = make_fpath('test-efi-fit-%s.dtb' % fdt_type)
-        utils.run_and_log(cons,
+        utils.run_and_log(ubman,
                           ['dtc', '-I', 'dts', '-O', 'dtb', '-o', dtb, dts])
         if comp:
-            utils.run_and_log(cons, ['gzip', '-f', dtb])
+            utils.run_and_log(ubman, ['gzip', '-f', dtb])
             dtb += '.gz'
         return dtb
 
@@ -292,7 +292,7 @@
         # Build the test ITS.
         fit_path = make_fpath('test-efi-fit-helloworld.fit')
         utils.run_and_log(
-            cons, [make_fpath('tools/mkimage'), '-f', its_path, fit_path])
+            ubman, [make_fpath('tools/mkimage'), '-f', its_path, fit_path])
         return fit_path
 
     def load_fit_from_host(fit):
@@ -308,9 +308,9 @@
 
         addr = fit.get('addr', None)
         if not addr:
-            addr = utils.find_ram_base(cons)
+            addr = utils.find_ram_base(ubman)
 
-        output = cons.run_command(
+        output = ubman.run_command(
             'host load hostfs - %x %s/%s' % (addr, fit['dn'], fit['fn']))
         expected_text = ' bytes read'
         size = fit.get('size', None)
@@ -335,10 +335,10 @@
 
         addr = fit.get('addr', None)
         if not addr:
-            addr = utils.find_ram_base(cons)
+            addr = utils.find_ram_base(ubman)
 
         file_name = fit['fn']
-        output = cons.run_command('tftpboot %x %s' % (addr, file_name))
+        output = ubman.run_command('tftpboot %x %s' % (addr, file_name))
         expected_text = 'Bytes transferred = '
         size = fit.get('size', None)
         if size:
@@ -349,10 +349,10 @@
         if not expected_crc:
             return addr
 
-        if cons.config.buildconfig.get('config_cmd_crc32', 'n') != 'y':
+        if ubman.config.buildconfig.get('config_cmd_crc32', 'n') != 'y':
             return addr
 
-        output = cons.run_command('crc32 $fileaddr $filesize')
+        output = ubman.run_command('crc32 $fileaddr $filesize')
         assert expected_crc in output
 
         return addr
@@ -384,10 +384,10 @@
                            generated content.
         """
 
-        with cons.log.section('FDT=%s;COMP=%s' % (enable_fdt, enable_comp)):
+        with ubman.log.section('FDT=%s;COMP=%s' % (enable_fdt, enable_comp)):
             if is_sandbox:
                 fit = {
-                    'dn': cons.config.build_dir,
+                    'dn': ubman.config.build_dir,
                 }
             else:
                 # Init networking.
@@ -397,7 +397,7 @@
                 if not net_set_up:
                     pytest.skip('Network not initialized')
 
-                fit = cons.config.env.get('env__efi_fit_tftp_file', None)
+                fit = ubman.config.env.get('env__efi_fit_tftp_file', None)
                 if not fit:
                     pytest.skip('No env__efi_fit_tftp_file binary specified in environment')
 
@@ -412,8 +412,8 @@
                 fit['size'] = os.path.getsize(fit_path)
 
                 # Copy image to TFTP root directory.
-                if fit['dn'] != cons.config.build_dir:
-                    utils.run_and_log(cons,
+                if fit['dn'] != ubman.config.build_dir:
+                    utils.run_and_log(ubman,
                                       ['mv', '-f', fit_path, '%s/' % fit['dn']])
 
             # Load FIT image.
@@ -423,31 +423,30 @@
             fit_config = 'config-efi-fdt' if enable_fdt else 'config-efi-nofdt'
 
             # Try booting.
-            output = cons.run_command('bootm %x#%s' % (addr, fit_config))
+            output = ubman.run_command('bootm %x#%s' % (addr, fit_config))
             if enable_fdt:
                 assert 'Booting using the fdt blob' in output
             assert 'Hello, world' in output
             assert '## Application failed' not in output
-            cons.restart_uboot()
+            ubman.restart_uboot()
 
-    cons = ubman
     # Array slice removes leading/trailing quotes.
-    sys_arch = cons.config.buildconfig.get('config_sys_arch', '"sandbox"')[1:-1]
+    sys_arch = ubman.config.buildconfig.get('config_sys_arch', '"sandbox"')[1:-1]
     if sys_arch == 'arm':
-        arm64 = cons.config.buildconfig.get('config_arm64')
+        arm64 = ubman.config.buildconfig.get('config_arm64')
         if arm64:
             sys_arch = 'arm64'
 
     is_sandbox = sys_arch == 'sandbox'
 
     if is_sandbox:
-        old_dtb = cons.config.dtb
+        old_dtb = ubman.config.dtb
 
     try:
         if is_sandbox:
             # Use our own device tree file, will be restored afterwards.
             control_dtb = make_dtb('internal', False)
-            cons.config.dtb = control_dtb
+            ubman.config.dtb = control_dtb
 
         # Run tests
         # - fdt OFF, gzip OFF
@@ -464,5 +463,5 @@
     finally:
         if is_sandbox:
             # Go back to the original U-Boot with the correct dtb.
-            cons.config.dtb = old_dtb
-            cons.restart_uboot()
+            ubman.config.dtb = old_dtb
+            ubman.restart_uboot()
diff --git a/test/py/tests/test_env.py b/test/py/tests/test_env.py
index 376ea7b..383e26c 100644
--- a/test/py/tests/test_env.py
+++ b/test/py/tests/test_env.py
@@ -177,9 +177,8 @@
 @pytest.mark.boardspec('sandbox')
 def test_env_initial_env_file(ubman):
     """Test that the u-boot-initial-env make target works"""
-    cons = ubman
-    builddir = 'O=' + cons.config.build_dir
-    envfile = cons.config.build_dir + '/u-boot-initial-env'
+    builddir = 'O=' + ubman.config.build_dir
+    envfile = ubman.config.build_dir + '/u-boot-initial-env'
 
     # remove if already exists from an older run
     try:
@@ -187,7 +186,7 @@
     except:
         pass
 
-    utils.run_and_log(cons, ['make', builddir, 'u-boot-initial-env'])
+    utils.run_and_log(ubman, ['make', builddir, 'u-boot-initial-env'])
 
     assert os.path.exists(envfile)
 
@@ -560,15 +559,14 @@
             fname = os.path.join(path, 'infile')
             with open(fname, 'w') as inf:
                 print(intext, file=inf)
-            result = utils.run_and_log(cons, ['awk', '-f', script, fname])
+            result = utils.run_and_log(ubman, ['awk', '-f', script, fname])
             if expect_val is not None:
                 expect = '#define CONFIG_EXTRA_ENV_TEXT "%s"\n' % expect_val
                 assert result == expect
             else:
                 assert result == ''
 
-    cons = ubman
-    script = os.path.join(cons.config.source_dir, 'scripts', 'env2string.awk')
+    script = os.path.join(ubman.config.source_dir, 'scripts', 'env2string.awk')
 
     # simple script with a single var
     check_script('fred=123', 'fred=123\\0')
diff --git a/test/py/tests/test_event_dump.py b/test/py/tests/test_event_dump.py
index 8297663..b9d48f5 100644
--- a/test/py/tests/test_event_dump.py
+++ b/test/py/tests/test_event_dump.py
@@ -11,9 +11,8 @@
 @pytest.mark.boardspec('sandbox')
 def test_event_dump(ubman):
     """Test that the "help" command can be executed."""
-    cons = ubman
-    sandbox = cons.config.build_dir + '/u-boot'
-    out = utils.run_and_log(cons, ['scripts/event_dump.py', sandbox])
+    sandbox = ubman.config.build_dir + '/u-boot'
+    out = utils.run_and_log(ubman, ['scripts/event_dump.py', sandbox])
     expect = '''.*Event type            Id                              Source location
 --------------------  ------------------------------  ------------------------------
 EVT_FT_FIXUP          bootmeth_vbe_ft_fixup           .*boot/vbe_request.c:.*
diff --git a/test/py/tests/test_fit.py b/test/py/tests/test_fit.py
index bfc20c4..619f731 100755
--- a/test/py/tests/test_fit.py
+++ b/test/py/tests/test_fit.py
@@ -127,7 +127,7 @@
         Return:
             Temporary filename
         """
-        return os.path.join(cons.config.build_dir, leaf)
+        return os.path.join(ubman.config.build_dir, leaf)
 
     def filesize(fname):
         """Get the size of a file
@@ -165,7 +165,7 @@
         return fname
 
     def make_compressed(filename):
-        utils.run_and_log(cons, ['gzip', '-f', '-k', filename])
+        utils.run_and_log(ubman, ['gzip', '-f', '-k', filename])
         return filename + '.gz'
 
     def find_matching(text, match):
@@ -260,10 +260,10 @@
           - run code coverage to make sure we are testing all the code
         """
         # Set up invariant files
-        control_dtb = fit_util.make_dtb(cons, base_fdt, 'u-boot')
-        kernel = fit_util.make_kernel(cons, 'test-kernel.bin', 'kernel')
+        control_dtb = fit_util.make_dtb(ubman, base_fdt, 'u-boot')
+        kernel = fit_util.make_kernel(ubman, 'test-kernel.bin', 'kernel')
         ramdisk = make_ramdisk('test-ramdisk.bin', 'ramdisk')
-        loadables1 = fit_util.make_kernel(cons, 'test-loadables1.bin', 'lenrek')
+        loadables1 = fit_util.make_kernel(ubman, 'test-loadables1.bin', 'lenrek')
         loadables2 = make_ramdisk('test-loadables2.bin', 'ksidmar')
         kernel_out = make_fname('kernel-out.bin')
         fdt = make_fname('u-boot.dtb')
@@ -311,16 +311,16 @@
         }
 
         # Make a basic FIT and a script to load it
-        fit = fit_util.make_fit(cons, mkimage, base_its, params)
+        fit = fit_util.make_fit(ubman, mkimage, base_its, params)
         params['fit'] = fit
         cmd = base_script % params
 
         # First check that we can load a kernel
         # We could perhaps reduce duplication with some loss of readability
-        cons.config.dtb = control_dtb
-        cons.restart_uboot()
-        with cons.log.section('Kernel load'):
-            output = cons.run_command_list(cmd.splitlines())
+        ubman.config.dtb = control_dtb
+        ubman.restart_uboot()
+        with ubman.log.section('Kernel load'):
+            output = ubman.run_command_list(cmd.splitlines())
             check_equal(kernel, kernel_out, 'Kernel not loaded')
             check_not_equal(control_dtb, fdt_out,
                             'FDT loaded but should be ignored')
@@ -340,7 +340,7 @@
                   (fit_offset, real_fit_offset))
 
             # Check if bootargs strings substitution works
-            output = cons.run_command_list([
+            output = ubman.run_command_list([
                 'env set bootargs \\\"\'my_boot_var=${foo}\'\\\"',
                 'env set foo bar',
                 'bootm prep',
@@ -348,63 +348,62 @@
             assert 'bootargs="my_boot_var=bar"' in output, "Bootargs strings not substituted"
 
         # Now a kernel and an FDT
-        with cons.log.section('Kernel + FDT load'):
+        with ubman.log.section('Kernel + FDT load'):
             params['fdt_load'] = 'load = <%#x>;' % params['fdt_addr']
-            fit = fit_util.make_fit(cons, mkimage, base_its, params)
-            cons.restart_uboot()
-            output = cons.run_command_list(cmd.splitlines())
+            fit = fit_util.make_fit(ubman, mkimage, base_its, params)
+            ubman.restart_uboot()
+            output = ubman.run_command_list(cmd.splitlines())
             check_equal(kernel, kernel_out, 'Kernel not loaded')
             check_equal(control_dtb, fdt_out, 'FDT not loaded')
             check_not_equal(ramdisk, ramdisk_out,
                             'Ramdisk loaded but should not be')
 
         # Try a ramdisk
-        with cons.log.section('Kernel + FDT + Ramdisk load'):
+        with ubman.log.section('Kernel + FDT + Ramdisk load'):
             params['ramdisk_config'] = 'ramdisk = "ramdisk-1";'
             params['ramdisk_load'] = 'load = <%#x>;' % params['ramdisk_addr']
-            fit = fit_util.make_fit(cons, mkimage, base_its, params)
-            cons.restart_uboot()
-            output = cons.run_command_list(cmd.splitlines())
+            fit = fit_util.make_fit(ubman, mkimage, base_its, params)
+            ubman.restart_uboot()
+            output = ubman.run_command_list(cmd.splitlines())
             check_equal(ramdisk, ramdisk_out, 'Ramdisk not loaded')
 
         # Configuration with some Loadables
-        with cons.log.section('Kernel + FDT + Ramdisk load + Loadables'):
+        with ubman.log.section('Kernel + FDT + Ramdisk load + Loadables'):
             params['loadables_config'] = 'loadables = "kernel-2", "ramdisk-2";'
             params['loadables1_load'] = ('load = <%#x>;' %
                                          params['loadables1_addr'])
             params['loadables2_load'] = ('load = <%#x>;' %
                                          params['loadables2_addr'])
-            fit = fit_util.make_fit(cons, mkimage, base_its, params)
-            cons.restart_uboot()
-            output = cons.run_command_list(cmd.splitlines())
+            fit = fit_util.make_fit(ubman, mkimage, base_its, params)
+            ubman.restart_uboot()
+            output = ubman.run_command_list(cmd.splitlines())
             check_equal(loadables1, loadables1_out,
                         'Loadables1 (kernel) not loaded')
             check_equal(loadables2, loadables2_out,
                         'Loadables2 (ramdisk) not loaded')
 
         # Kernel, FDT and Ramdisk all compressed
-        with cons.log.section('(Kernel + FDT + Ramdisk) compressed'):
+        with ubman.log.section('(Kernel + FDT + Ramdisk) compressed'):
             params['compression'] = 'gzip'
             params['kernel'] = make_compressed(kernel)
             params['fdt'] = make_compressed(fdt)
             params['ramdisk'] = make_compressed(ramdisk)
-            fit = fit_util.make_fit(cons, mkimage, base_its, params)
-            cons.restart_uboot()
-            output = cons.run_command_list(cmd.splitlines())
+            fit = fit_util.make_fit(ubman, mkimage, base_its, params)
+            ubman.restart_uboot()
+            output = ubman.run_command_list(cmd.splitlines())
             check_equal(kernel, kernel_out, 'Kernel not loaded')
             check_equal(control_dtb, fdt_out, 'FDT not loaded')
             check_not_equal(ramdisk, ramdisk_out, 'Ramdisk got decompressed?')
             check_equal(ramdisk + '.gz', ramdisk_out, 'Ramdist not loaded')
 
 
-    cons = ubman
     # We need to use our own device tree file. Remember to restore it
     # afterwards.
-    old_dtb = cons.config.dtb
+    old_dtb = ubman.config.dtb
     try:
-        mkimage = cons.config.build_dir + '/tools/mkimage'
+        mkimage = ubman.config.build_dir + '/tools/mkimage'
         run_fit_test(mkimage)
     finally:
         # Go back to the original U-Boot with the correct dtb.
-        cons.config.dtb = old_dtb
-        cons.restart_uboot()
+        ubman.config.dtb = old_dtb
+        ubman.restart_uboot()
diff --git a/test/py/tests/test_fit_auto_signed.py b/test/py/tests/test_fit_auto_signed.py
index b5f872f..cdfd341 100644
--- a/test/py/tests/test_fit_auto_signed.py
+++ b/test/py/tests/test_fit_auto_signed.py
@@ -26,22 +26,22 @@
 
 class SignedFitHelper(object):
     """Helper to manipulate a FIT with signed/hashed images/configs."""
-    def __init__(self, cons, file_name):
+    def __init__(self, ubman, file_name):
         self.fit = file_name
-        self.cons = cons
+        self.ubman = ubman
         self.images_nodes = set()
         self.confgs_nodes = set()
 
     def __fdt_list(self, path):
-        return utils.run_and_log(self.cons,
+        return utils.run_and_log(self.ubman,
             f'fdtget -l {self.fit} {path}')
 
     def __fdt_get_string(self, node, prop):
-        return utils.run_and_log(self.cons,
+        return utils.run_and_log(self.ubman,
             f'fdtget -ts {self.fit} {node} {prop}')
 
     def __fdt_get_binary(self, node, prop):
-        numbers = utils.run_and_log(self.cons,
+        numbers = utils.run_and_log(self.ubman,
             f'fdtget -tbi {self.fit} {node} {prop}')
 
         bignum = bytearray()
@@ -133,9 +133,8 @@
 
     The test does not run the sandbox. It only checks the host tool mkimage.
     """
-    cons = ubman
-    mkimage = cons.config.build_dir + '/tools/mkimage'
-    tempdir = os.path.join(cons.config.result_dir, 'auto_fit')
+    mkimage = ubman.config.build_dir + '/tools/mkimage'
+    tempdir = os.path.join(ubman.config.result_dir, 'auto_fit')
     os.makedirs(tempdir, exist_ok=True)
     kernel_file = f'{tempdir}/vmlinuz'
     dt1_file = f'{tempdir}/dt-1.dtb'
@@ -166,29 +165,29 @@
     s_args = " -k" + tempdir + " -g" + key_name + " -o" + sign_algo
 
     # 1 - Create auto FIT with images crc32 checksum, and verify it
-    utils.run_and_log(cons, mkimage + ' -fauto' + b_args + " " + fit_file)
+    utils.run_and_log(ubman, mkimage + ' -fauto' + b_args + " " + fit_file)
 
-    fit = SignedFitHelper(cons, fit_file)
+    fit = SignedFitHelper(ubman, fit_file)
     if fit.build_nodes_sets() == 0:
         raise ValueError('FIT-1 has no "/image" nor "/configuration" nodes')
 
     fit.check_fit_crc32_images()
 
     # 2 - Create auto FIT with signed images, and verify it
-    utils.run_and_log(cons, mkimage + ' -fauto' + b_args + s_args + " " +
+    utils.run_and_log(ubman, mkimage + ' -fauto' + b_args + s_args + " " +
                       fit_file)
 
-    fit = SignedFitHelper(cons, fit_file)
+    fit = SignedFitHelper(ubman, fit_file)
     if fit.build_nodes_sets() == 0:
         raise ValueError('FIT-2 has no "/image" nor "/configuration" nodes')
 
     fit.check_fit_signed_images(key_name, sign_algo, verifier)
 
     # 3 - Create auto FIT with signed configs and hashed images, and verify it
-    utils.run_and_log(cons, mkimage + ' -fauto-conf' + b_args + s_args + " " +
+    utils.run_and_log(ubman, mkimage + ' -fauto-conf' + b_args + s_args + " " +
                       fit_file)
 
-    fit = SignedFitHelper(cons, fit_file)
+    fit = SignedFitHelper(ubman, fit_file)
     if fit.build_nodes_sets() == 0:
         raise ValueError('FIT-3 has no "/image" nor "/configuration" nodes')
 
diff --git a/test/py/tests/test_fit_ecdsa.py b/test/py/tests/test_fit_ecdsa.py
index 63f2f6a..3e816d6 100644
--- a/test/py/tests/test_fit_ecdsa.py
+++ b/test/py/tests/test_fit_ecdsa.py
@@ -19,21 +19,21 @@
 
 class SignableFitImage(object):
     """ Helper to manipulate a FIT image on disk """
-    def __init__(self, cons, file_name):
+    def __init__(self, ubman, file_name):
         self.fit = file_name
-        self.cons = cons
+        self.ubman = ubman
         self.signable_nodes = set()
 
     def __fdt_list(self, path):
-        return utils.run_and_log(self.cons, f'fdtget -l {self.fit} {path}')
+        return utils.run_and_log(self.ubman, f'fdtget -l {self.fit} {path}')
 
     def __fdt_set(self, node, **prop_value):
         for prop, value in prop_value.items():
-            utils.run_and_log(self.cons,
+            utils.run_and_log(self.ubman,
                               f'fdtput -ts {self.fit} {node} {prop} {value}')
 
     def __fdt_get_binary(self, node, prop):
-        numbers = utils.run_and_log(self.cons,
+        numbers = utils.run_and_log(self.ubman,
                                     f'fdtget -tbi {self.fit} {node} {prop}')
 
         bignum = bytearray()
@@ -55,7 +55,7 @@
             self.__fdt_set(f'{image}/signature', algo='sha256,ecdsa256')
 
     def sign(self, mkimage, key_file):
-        utils.run_and_log(self.cons, [mkimage, '-F', self.fit, f'-G{key_file}'])
+        utils.run_and_log(self.ubman, [mkimage, '-F', self.fit, f'-G{key_file}'])
 
     def check_signatures(self, key):
         for image in self.signable_nodes:
@@ -78,16 +78,15 @@
 
     def assemble_fit_image(dest_fit, its, destdir):
         dtc_args = f'-I dts -O dtb -i {destdir}'
-        utils.run_and_log(cons, [mkimage, '-D', dtc_args, '-f', its, dest_fit])
+        utils.run_and_log(ubman, [mkimage, '-D', dtc_args, '-f', its, dest_fit])
 
     def dtc(dts):
         dtb = dts.replace('.dts', '.dtb')
-        utils.run_and_log(cons, f'dtc {datadir}/{dts} -O dtb -o {tempdir}/{dtb}')
+        utils.run_and_log(ubman, f'dtc {datadir}/{dts} -O dtb -o {tempdir}/{dtb}')
 
-    cons = ubman
-    mkimage = cons.config.build_dir + '/tools/mkimage'
-    datadir = cons.config.source_dir + '/test/py/tests/vboot/'
-    tempdir = os.path.join(cons.config.result_dir, 'ecdsa')
+    mkimage = ubman.config.build_dir + '/tools/mkimage'
+    datadir = ubman.config.source_dir + '/test/py/tests/vboot/'
+    tempdir = os.path.join(ubman.config.result_dir, 'ecdsa')
     os.makedirs(tempdir, exist_ok=True)
     key_file = f'{tempdir}/ecdsa-test-key.pem'
     fit_file = f'{tempdir}/test.fit'
@@ -105,7 +104,7 @@
 
     assemble_fit_image(fit_file, f'{datadir}/sign-images-sha256.its', tempdir)
 
-    fit = SignableFitImage(cons, fit_file)
+    fit = SignableFitImage(ubman, fit_file)
     nodes = fit.find_signable_image_nodes()
     if len(nodes) == 0:
         raise ValueError('FIT image has no "/image" nodes with "signature"')
diff --git a/test/py/tests/test_fit_hashes.py b/test/py/tests/test_fit_hashes.py
index bcde045..07bf0fd 100644
--- a/test/py/tests/test_fit_hashes.py
+++ b/test/py/tests/test_fit_hashes.py
@@ -26,20 +26,20 @@
 
 class ReadonlyFitImage(object):
     """ Helper to manipulate a FIT image on disk """
-    def __init__(self, cons, file_name):
+    def __init__(self, ubman, file_name):
         self.fit = file_name
-        self.cons = cons
+        self.ubman = ubman
         self.hashable_nodes = set()
 
     def __fdt_list(self, path):
-        return utils.run_and_log(self.cons, f'fdtget -l {self.fit} {path}')
+        return utils.run_and_log(self.ubman, f'fdtget -l {self.fit} {path}')
 
     def __fdt_get(self, node, prop):
-        val = utils.run_and_log(self.cons, f'fdtget {self.fit} {node} {prop}')
+        val = utils.run_and_log(self.ubman, f'fdtget {self.fit} {node} {prop}')
         return val.rstrip('\n')
 
     def __fdt_get_sexadecimal(self, node, prop):
-        numbers = utils.run_and_log(self.cons,
+        numbers = utils.run_and_log(self.ubman,
                                     f'fdtget -tbx {self.fit} {node} {prop}')
 
         sexadecimal = ''
@@ -86,17 +86,16 @@
 
     def assemble_fit_image(dest_fit, its, destdir):
         dtc_args = f'-I dts -O dtb -i {destdir}'
-        utils.run_and_log(cons, [mkimage, '-D', dtc_args, '-f', its, dest_fit])
+        utils.run_and_log(ubman, [mkimage, '-D', dtc_args, '-f', its, dest_fit])
 
     def dtc(dts):
         dtb = dts.replace('.dts', '.dtb')
-        utils.run_and_log(cons,
+        utils.run_and_log(ubman,
                           f'dtc {datadir}/{dts} -O dtb -o {tempdir}/{dtb}')
 
-    cons = ubman
-    mkimage = cons.config.build_dir + '/tools/mkimage'
-    datadir = cons.config.source_dir + '/test/py/tests/vboot/'
-    tempdir = os.path.join(cons.config.result_dir, 'hashes')
+    mkimage = ubman.config.build_dir + '/tools/mkimage'
+    datadir = ubman.config.source_dir + '/test/py/tests/vboot/'
+    tempdir = os.path.join(ubman.config.result_dir, 'hashes')
     os.makedirs(tempdir, exist_ok=True)
 
     fit_file = f'{tempdir}/test.fit'
@@ -108,7 +107,7 @@
 
     assemble_fit_image(fit_file, f'{datadir}/hash-images.its', tempdir)
 
-    fit = ReadonlyFitImage(cons, fit_file)
+    fit = ReadonlyFitImage(ubman, fit_file)
     nodes = fit.find_hashable_image_nodes()
     if len(nodes) == 0:
         raise ValueError('FIT image has no "/image" nodes with "hash-..."')
diff --git a/test/py/tests/test_handoff.py b/test/py/tests/test_handoff.py
index c0cfa3b..becd7d7 100644
--- a/test/py/tests/test_handoff.py
+++ b/test/py/tests/test_handoff.py
@@ -10,6 +10,5 @@
 @pytest.mark.buildconfigspec('spl')
 def test_handoff(ubman):
     """Test that of-platdata can be generated and used in sandbox"""
-    cons = ubman
-    response = cons.run_command('sb handoff')
+    response = ubman.run_command('sb handoff')
     assert ('SPL handoff magic %x' % TEST_HANDOFF_MAGIC) in response
diff --git a/test/py/tests/test_help.py b/test/py/tests/test_help.py
index 72f7282..12cb36b 100644
--- a/test/py/tests/test_help.py
+++ b/test/py/tests/test_help.py
@@ -16,10 +16,9 @@
 @pytest.mark.boardspec('sandbox')
 def test_help_no_devicetree(ubman):
     try:
-        cons = ubman
-        cons.restart_uboot_with_flags([], use_dtb=False)
-        cons.run_command('help')
-        output = cons.get_spawn_output().replace('\r', '')
+        ubman.restart_uboot_with_flags([], use_dtb=False)
+        ubman.run_command('help')
+        output = ubman.get_spawn_output().replace('\r', '')
         assert 'print command description/usage' in output
     finally:
         # Restart afterward to get the normal device tree back
@@ -28,10 +27,9 @@
 @pytest.mark.boardspec('sandbox_vpl')
 def test_vpl_help(ubman):
     try:
-        cons = ubman
-        cons.restart_uboot()
-        cons.run_command('help')
-        output = cons.get_spawn_output().replace('\r', '')
+        ubman.restart_uboot()
+        ubman.run_command('help')
+        output = ubman.get_spawn_output().replace('\r', '')
         assert 'print command description/usage' in output
     finally:
         # Restart afterward to get the normal device tree back
diff --git a/test/py/tests/test_kconfig.py b/test/py/tests/test_kconfig.py
index a3796ea..0c261d4 100644
--- a/test/py/tests/test_kconfig.py
+++ b/test/py/tests/test_kconfig.py
@@ -13,11 +13,10 @@
 @pytest.mark.boardspec('sandbox')
 def test_kconfig(ubman):
     """Test build failures when IF_ENABLED_INT() option is not enabled"""
-    cons = ubman
 
     # This detects build errors in test/lib/kconfig.c
     out = utils.run_and_log(
-        cons, ['./tools/buildman/buildman', '-m', '--board', 'sandbox',
+        ubman, ['./tools/buildman/buildman', '-m', '--board', 'sandbox',
                '-a', 'TEST_KCONFIG', '-o', TMPDIR], ignore_errors=True)
     assert 'invalid_use_of_IF_ENABLED_INT' in out
     assert 'invalid_use_of_CONFIG_IF_ENABLED_INT' in out
@@ -26,11 +25,10 @@
 @pytest.mark.boardspec('sandbox_spl')
 def test_kconfig_spl(ubman):
     """Test build failures when IF_ENABLED_INT() option is not enabled"""
-    cons = ubman
 
     # This detects build errors in test/lib/kconfig_spl.c
     out = utils.run_and_log(
-        cons, ['./tools/buildman/buildman', '-m', '--board', 'sandbox_spl',
+        ubman, ['./tools/buildman/buildman', '-m', '--board', 'sandbox_spl',
                '-a', 'TEST_KCONFIG', '-o', TMPDIR], ignore_errors=True)
     assert 'invalid_use_of_IF_ENABLED_INT' in out
 
diff --git a/test/py/tests/test_log.py b/test/py/tests/test_log.py
index 292f5b3..4558b03 100644
--- a/test/py/tests/test_log.py
+++ b/test/py/tests/test_log.py
@@ -20,18 +20,17 @@
             fmt: Format to use for 'log format'
             expected_output: Expected output from the 'log rec' command
         """
-        output = cons.run_command('log format %s' % fmt)
+        output = ubman.run_command('log format %s' % fmt)
         assert output == ''
-        output = cons.run_command('log rec arch notice file.c 123 func msg')
+        output = ubman.run_command('log rec arch notice file.c 123 func msg')
         assert output == expected_output
 
-    cons = ubman
-    with cons.log.section('format'):
+    with ubman.log.section('format'):
         pad = int(ubman.config.buildconfig.get('config_logf_func_pad'))
         padding = ' ' * (pad - len('func'))
 
         run_with_format('all', f'NOTICE.arch,file.c:123-{padding}func() msg')
-        output = cons.run_command('log format')
+        output = ubman.run_command('log format')
         assert output == 'Log format: clFLfm'
 
         run_with_format('fm', f'{padding}func() msg')
@@ -45,7 +44,6 @@
 def test_log_dropped(ubman):
     """Test dropped 'log' message when debug_uart is activated"""
 
-    cons = ubman
-    cons.restart_uboot()
-    output = cons.get_spawn_output().replace('\r', '')
+    ubman.restart_uboot()
+    output = ubman.get_spawn_output().replace('\r', '')
     assert (not 'debug: main' in output)
diff --git a/test/py/tests/test_mmc.py b/test/py/tests/test_mmc.py
index 4916dcd..e751a3b 100644
--- a/test/py/tests/test_mmc.py
+++ b/test/py/tests/test_mmc.py
@@ -32,19 +32,19 @@
 mmc_modes_name = []
 mmc_modes = []
 
-def setup_mmc_modes(cons):
+def setup_mmc_modes(ubman):
     global mmc_modes, mmc_modes_name
-    f = cons.config.env.get('env__mmc_device', None)
+    f = ubman.config.env.get('env__mmc_device', None)
     if f:
         mmc_modes_name = f.get('mmc_modes', None)
 
     # Set mmc mode to default mode (legacy), if speed mode config isn't enabled
-    if cons.config.buildconfig.get('config_mmc_speed_mode_set', 'n') != 'y':
+    if ubman.config.buildconfig.get('config_mmc_speed_mode_set', 'n') != 'y':
         mmc_modes = [0]
         return
 
     if mmc_modes_name:
-        mmc_help = cons.run_command('mmc -help')
+        mmc_help = ubman.run_command('mmc -help')
         m = re.search(r"\[MMC_LEGACY(.*\n.+])", mmc_help)
         modes = [
             x.strip()
diff --git a/test/py/tests/test_of_migrate.py b/test/py/tests/test_of_migrate.py
index e866eeb..ab89332 100644
--- a/test/py/tests/test_of_migrate.py
+++ b/test/py/tests/test_of_migrate.py
@@ -14,11 +14,11 @@
 TMPDIR2 = '/tmp/test_no_migrate_spl'
 TMPDIR3 = '/tmp/test_migrate'
 
-def build_for_migrate(cons, replace_pair, board, tmpdir, disable_migrate=True):
+def build_for_migrate(ubman, replace_pair, board, tmpdir, disable_migrate=True):
     """Build an updated U-Boot with a slightly modified device tree
 
     Args:
-        cons (ConsoleBase): U-Boot console
+        ubman (ConsoleBase): U-Boot console
         replace_pair (tuple):
             String to find
             String to replace it with
@@ -26,14 +26,14 @@
         tmpdir (str): Temporary directory to use
         disable_migrate (bool): True to disable CONFIG_OF_TAG_MIGRATE in build
     """
-    srcdir = cons.config.source_dir
-    build_dir = cons.config.build_dir
+    srcdir = ubman.config.source_dir
+    build_dir = ubman.config.build_dir
 
     # Get the source for the existing dts
     dt_dir = os.path.join(build_dir, 'arch', 'sandbox', 'dts')
     orig_fname = os.path.join(dt_dir, 'sandbox.dtb')
     out_dts = os.path.join(dt_dir, 'sandbox_out.dts')
-    utils.run_and_log(cons, ['dtc', orig_fname, '-I', 'dtb', '-O', 'dts',
+    utils.run_and_log(ubman, ['dtc', orig_fname, '-I', 'dtb', '-O', 'dts',
                              '-o', out_dts])
 
     # Update it to use an old tag
@@ -45,7 +45,7 @@
     with open(dts_fname, 'w') as outf:
         print(data, file=outf)
     dtb_fname = os.path.join(dt_dir, 'sandbox_oldtag.dtb')
-    utils.run_and_log(cons, ['dtc', dts_fname, '-o', dtb_fname])
+    utils.run_and_log(ubman, ['dtc', dts_fname, '-o', dtb_fname])
 
     migrate = ['-a', '~CONFIG_OF_TAG_MIGRATE'] if disable_migrate else []
 
@@ -55,7 +55,7 @@
     env['DEVICE_TREE'] = 'sandbox_new'
     env['NO_LTO'] = '1'  # Speed up build
     out = utils.run_and_log(
-        cons, ['./tools/buildman/buildman', '-m', '--board', board,
+        ubman, ['./tools/buildman/buildman', '-m', '--board', board,
                *migrate, '-w', '-o', tmpdir], ignore_errors=True, env=env)
     return out
 
@@ -63,15 +63,14 @@
 @pytest.mark.boardspec('sandbox')
 def test_of_no_migrate(ubman):
     """Test sandbox with old boot phase tags like u-boot,dm-pre-proper"""
-    cons = ubman
 
-    build_for_migrate(cons, ['bootph-some-ram', 'u-boot,dm-pre-proper'],
+    build_for_migrate(ubman, ['bootph-some-ram', 'u-boot,dm-pre-proper'],
                       'sandbox', TMPDIR1)
 
     # It should fail to run, since the lcd device will not be bound before
     # relocation. so won't get its frame-buffer memory
     out = utils.run_and_log(
-        cons, [os.path.join(TMPDIR1, 'u-boot'), '-D', '-c', 'help'],
+        ubman, [os.path.join(TMPDIR1, 'u-boot'), '-D', '-c', 'help'],
         ignore_errors=True)
     assert "Video device 'lcd' cannot allocate frame buffer memory" in out
 
@@ -82,9 +81,8 @@
 @pytest.mark.boardspec('!sandbox_tpl')
 def test_of_no_migrate_spl(ubman):
     """Test sandbox with old boot phase tags like u-boot,dm-spl"""
-    cons = ubman
 
-    out = build_for_migrate(cons, ['bootph-pre-ram', 'u-boot,dm-spl'],
+    out = build_for_migrate(ubman, ['bootph-pre-ram', 'u-boot,dm-spl'],
                             'sandbox_spl', TMPDIR2)
 
     # It should fail to build, since the SPL DT will not include 'spl-test'
@@ -96,13 +94,12 @@
 @pytest.mark.boardspec('sandbox')
 def test_of_migrate(ubman):
     """Test sandbox shows a message when tags were migrated"""
-    cons = ubman
 
-    build_for_migrate(cons, ['bootph-some-ram', 'u-boot,dm-pre-proper'],
+    build_for_migrate(ubman, ['bootph-some-ram', 'u-boot,dm-pre-proper'],
                       'sandbox', TMPDIR3, disable_migrate=False)
 
     # It should show a migration message
     out = utils.run_and_log(
-        cons, [os.path.join(TMPDIR3, 'u-boot'), '-D', '-c', 'help'],
+        ubman, [os.path.join(TMPDIR3, 'u-boot'), '-D', '-c', 'help'],
         ignore_errors=True)
     assert "Warning: Device tree includes old 'u-boot,dm-' tags" in out
diff --git a/test/py/tests/test_ofplatdata.py b/test/py/tests/test_ofplatdata.py
index b4d2db0..d31fa55 100644
--- a/test/py/tests/test_ofplatdata.py
+++ b/test/py/tests/test_ofplatdata.py
@@ -8,10 +8,9 @@
 @pytest.mark.buildconfigspec('spl_of_platdata')
 def test_spl_devicetree(ubman):
     """Test content of spl device-tree"""
-    cons = ubman
-    dtb = cons.config.build_dir + '/spl/u-boot-spl.dtb'
-    fdtgrep = cons.config.build_dir + '/tools/fdtgrep'
-    output = utils.run_and_log(cons, [fdtgrep, '-l', dtb])
+    dtb = ubman.config.build_dir + '/spl/u-boot-spl.dtb'
+    fdtgrep = ubman.config.build_dir + '/tools/fdtgrep'
+    output = utils.run_and_log(ubman, [fdtgrep, '-l', dtb])
 
     assert "bootph-all" not in output
     assert "bootph-some-ram" not in output
diff --git a/test/py/tests/test_sandbox_opts.py b/test/py/tests/test_sandbox_opts.py
index f50302c..48f5b31 100644
--- a/test/py/tests/test_sandbox_opts.py
+++ b/test/py/tests/test_sandbox_opts.py
@@ -13,18 +13,16 @@
 @pytest.mark.boardspec('sandbox')
 def test_sandbox_cmdline(ubman):
     """Test building sandbox without CONFIG_CMDLINE"""
-    cons = ubman
 
     utils.run_and_log(
-        cons, ['./tools/buildman/buildman', '-m', '--board', 'sandbox',
+        ubman, ['./tools/buildman/buildman', '-m', '--board', 'sandbox',
                '-a', '~CMDLINE', '-o', TMPDIR])
 
 @pytest.mark.slow
 @pytest.mark.boardspec('sandbox')
 def test_sandbox_lto(ubman):
     """Test building sandbox without CONFIG_LTO"""
-    cons = ubman
 
     utils.run_and_log(
-        cons, ['./tools/buildman/buildman', '-m', '--board', 'sandbox',
+        ubman, ['./tools/buildman/buildman', '-m', '--board', 'sandbox',
                '-a', '~LTO', '-o', TMPDIR])
diff --git a/test/py/tests/test_source.py b/test/py/tests/test_source.py
index f0437aa..970d8c7 100644
--- a/test/py/tests/test_source.py
+++ b/test/py/tests/test_source.py
@@ -11,27 +11,26 @@
 @pytest.mark.buildconfigspec('fit')
 def test_source(ubman):
     # Compile our test script image
-    cons = ubman
-    mkimage = os.path.join(cons.config.build_dir, 'tools/mkimage')
-    its = os.path.join(cons.config.source_dir, 'test/py/tests/source.its')
-    fit = os.path.join(cons.config.build_dir, 'source.itb')
-    utils.run_and_log(cons, (mkimage, '-f', its, fit))
-    cons.run_command(f'host load hostfs - $loadaddr {fit}')
+    mkimage = os.path.join(ubman.config.build_dir, 'tools/mkimage')
+    its = os.path.join(ubman.config.source_dir, 'test/py/tests/source.its')
+    fit = os.path.join(ubman.config.build_dir, 'source.itb')
+    utils.run_and_log(ubman, (mkimage, '-f', its, fit))
+    ubman.run_command(f'host load hostfs - $loadaddr {fit}')
 
-    assert '2' in cons.run_command('source')
-    assert '1' in cons.run_command('source :')
-    assert '1' in cons.run_command('source :script-1')
-    assert '2' in cons.run_command('source :script-2')
-    assert 'Fail' in cons.run_command('source :not-a-script || echo Fail')
-    assert '2' in cons.run_command('source \\#')
-    assert '1' in cons.run_command('source \\#conf-1')
-    assert '2' in cons.run_command('source \\#conf-2')
+    assert '2' in ubman.run_command('source')
+    assert '1' in ubman.run_command('source :')
+    assert '1' in ubman.run_command('source :script-1')
+    assert '2' in ubman.run_command('source :script-2')
+    assert 'Fail' in ubman.run_command('source :not-a-script || echo Fail')
+    assert '2' in ubman.run_command('source \\#')
+    assert '1' in ubman.run_command('source \\#conf-1')
+    assert '2' in ubman.run_command('source \\#conf-2')
 
-    cons.run_command('fdt addr $loadaddr')
-    cons.run_command('fdt rm /configurations default')
-    assert '1' in cons.run_command('source')
-    assert 'Fail' in cons.run_command('source \\# || echo Fail')
+    ubman.run_command('fdt addr $loadaddr')
+    ubman.run_command('fdt rm /configurations default')
+    assert '1' in ubman.run_command('source')
+    assert 'Fail' in ubman.run_command('source \\# || echo Fail')
 
-    cons.run_command('fdt rm /images default')
-    assert 'Fail' in cons.run_command('source || echo Fail')
-    assert 'Fail' in cons.run_command('source \\# || echo Fail')
+    ubman.run_command('fdt rm /images default')
+    assert 'Fail' in ubman.run_command('source || echo Fail')
+    assert 'Fail' in ubman.run_command('source \\# || echo Fail')
diff --git a/test/py/tests/test_spl.py b/test/py/tests/test_spl.py
index 6b226c2..4840739 100644
--- a/test/py/tests/test_spl.py
+++ b/test/py/tests/test_spl.py
@@ -33,9 +33,8 @@
         ut_subtest (str): SPL test to be executed (e.g. 'dm platdata_phandle')
     """
     try:
-        cons = ubman
-        cons.restart_uboot_with_flags(['-u', '-k', ut_spl_subtest.split()[1]])
-        output = cons.get_spawn_output().replace('\r', '')
+        ubman.restart_uboot_with_flags(['-u', '-k', ut_spl_subtest.split()[1]])
+        output = ubman.get_spawn_output().replace('\r', '')
         assert 'failures: 0' in output
     finally:
         # Restart afterward in case a non-SPL test is run next. This should not
diff --git a/test/py/tests/test_suite.py b/test/py/tests/test_suite.py
index c7f4ded..7fe9a90 100644
--- a/test/py/tests/test_suite.py
+++ b/test/py/tests/test_suite.py
@@ -18,11 +18,11 @@
 DEBUG_ME = False
 
 
-def collect_info(cons, output):
+def collect_info(ubman, output):
     """Process the output from 'ut all'
 
     Args:
-        cons: U-Boot console object
+        ubman: U-Boot console object
         output: Output from running 'ut all'
 
     Returns:
@@ -45,15 +45,15 @@
     for line in output.splitlines():
         line = line.rstrip()
         if DEBUG_ME:
-            cons.log.info(f'line: {line}')
+            ubman.log.info(f'line: {line}')
         m = re.search('----Running ([^ ]*) tests----', line)
         if m:
             if DEBUG_ME and cur_suite and cur_suite != 'info':
-                cons.log.info(f'suite: {cur_suite} expected {exp_test_count[cur_suite]} found {test_count}')
+                ubman.log.info(f'suite: {cur_suite} expected {exp_test_count[cur_suite]} found {test_count}')
 
             cur_suite = m.group(1)
             if DEBUG_ME:
-                cons.log.info(f'cur_suite: {cur_suite}')
+                ubman.log.info(f'cur_suite: {cur_suite}')
             suites.add(cur_suite)
 
             test_count = 0
@@ -65,7 +65,7 @@
             test_name = m.group(1)
             msg = m.group(3)
             if DEBUG_ME:
-                cons.log.info(f"test_name {test_name} msg '{msg}'")
+                ubman.log.info(f"test_name {test_name} msg '{msg}'")
             full_name = f'{cur_suite}.{test_name}'
             if msg == ' (flat tree)' and full_name not in tests:
                 tests.add(full_name)
@@ -74,10 +74,10 @@
                 tests.add(full_name)
                 test_count += 1
         if DEBUG_ME:
-            cons.log.info(f'test_count {test_count}')
+            ubman.log.info(f'test_count {test_count}')
     if DEBUG_ME:
-        cons.log.info(f'suite: {cur_suite} expected {exp_test_count[cur_suite]} found {test_count}')
-        cons.log.info(f"Tests: {' '.join(sorted(list(tests)))}")
+        ubman.log.info(f'suite: {cur_suite} expected {exp_test_count[cur_suite]} found {test_count}')
+        ubman.log.info(f"Tests: {' '.join(sorted(list(tests)))}")
 
     # Figure out what is missing, or extra
     missing = set()
@@ -91,11 +91,11 @@
     return suites, tests, exp_test_count, missing, extra
 
 
-def process_ut_info(cons, output):
+def process_ut_info(ubman, output):
     """Process the output of the 'ut info' command
 
     Args:
-        cons: U-Boot console object
+        ubman: U-Boot console object
         output: Output from running 'ut all'
 
     Returns:
@@ -113,7 +113,7 @@
     for line in output.splitlines():
         line = line.rstrip()
         if DEBUG_ME:
-            cons.log.info(f'line: {line}')
+            ubman.log.info(f'line: {line}')
         m = re.match(r'Test suites: (.*)', line)
         if m:
             suite_count = int(m.group(1))
@@ -142,45 +142,44 @@
        - The expected set of suites is run (the list is hard-coded in this test)
 
     """
-    cons = ubman
     buildconfig = u_boot_config.buildconfig
-    with cons.log.section('Run all unit tests'):
+    with ubman.log.section('Run all unit tests'):
         # ut hush hush_test_simple_dollar prints "Unknown command" on purpose.
         with ubman.disable_check('unknown_command'):
-            output = cons.run_command('ut all')
+            output = ubman.run_command('ut all')
 
     # Process the output from the run
-    with cons.log.section('Check output'):
-        suites, all_tests, exp_test_count, missing, extra = collect_info(cons,
+    with ubman.log.section('Check output'):
+        suites, all_tests, exp_test_count, missing, extra = collect_info(ubman,
                                                                          output)
-    cons.log.info(f'missing {missing}')
-    cons.log.info(f'extra {extra}')
+    ubman.log.info(f'missing {missing}')
+    ubman.log.info(f'extra {extra}')
 
     # Make sure we got a test count for each suite
     assert not (suites - exp_test_count.keys())
 
     # Deal with missing suites
-    with cons.log.section('Check missing suites'):
+    with ubman.log.section('Check missing suites'):
         if 'config_cmd_seama' not in buildconfig:
-            cons.log.info("CMD_SEAMA not enabled: Ignoring suite 'seama'")
+            ubman.log.info("CMD_SEAMA not enabled: Ignoring suite 'seama'")
             missing.discard('seama')
 
     # Run 'ut info' and compare with the log results
-    with cons.log.section('Check suite test-counts'):
-        output = cons.run_command('ut -s info')
+    with ubman.log.section('Check suite test-counts'):
+        output = ubman.run_command('ut -s info')
 
-        suite_count, total_test_count, test_count = process_ut_info(cons,
+        suite_count, total_test_count, test_count = process_ut_info(ubman,
                                                                     output)
 
         if missing or extra:
-            cons.log.info(f"suites: {' '.join(sorted(list(suites)))}")
-            cons.log.error(f'missing: {sorted(list(missing))}')
-            cons.log.error(f'extra: {sorted(list(extra))}')
+            ubman.log.info(f"suites: {' '.join(sorted(list(suites)))}")
+            ubman.log.error(f'missing: {sorted(list(missing))}')
+            ubman.log.error(f'extra: {sorted(list(extra))}')
 
         assert not missing, f'Missing suites {missing}'
         assert not extra, f'Extra suites {extra}'
 
-        cons.log.info(str(exp_test_count))
+        ubman.log.info(str(exp_test_count))
         for suite in EXPECTED_SUITES:
             assert test_count[suite] in ['?', str(exp_test_count[suite])], \
                 f'suite {suite} expected {exp_test_count[suite]}'
@@ -189,18 +188,18 @@
         assert total_test_count == len(all_tests)
 
     # Run three suites
-    with cons.log.section('Check multiple suites'):
-        output = cons.run_command('ut bloblist,setexpr,mem')
+    with ubman.log.section('Check multiple suites'):
+        output = ubman.run_command('ut bloblist,setexpr,mem')
         assert 'Suites run: 3' in output
 
     # Run a particular test
-    with cons.log.section('Check single test'):
-        output = cons.run_command('ut bloblist reloc')
+    with ubman.log.section('Check single test'):
+        output = ubman.run_command('ut bloblist reloc')
         assert 'Test: reloc: bloblist.c' in output
 
     # Run tests multiple times
-    with cons.log.section('Check multiple runs'):
-        output = cons.run_command('ut -r2 bloblist')
+    with ubman.log.section('Check multiple runs'):
+        output = ubman.run_command('ut -r2 bloblist')
         lines = output.splitlines()
         run = len([line for line in lines if 'Test:' in line])
         count = re.search(r'Tests run: (\d*)', lines[-1]).group(1)
diff --git a/test/py/tests/test_tpm2.py b/test/py/tests/test_tpm2.py
index ade102a..064651c 100644
--- a/test/py/tests/test_tpm2.py
+++ b/test/py/tests/test_tpm2.py
@@ -50,9 +50,9 @@
             ubman.run_command('tpm2 clear TPM2_RH_PLATFORM')
         ubman.run_command('echo --- end of init ---')
 
-def is_sandbox(cons):
+def is_sandbox(ubman):
     # Array slice removes leading/trailing quotes.
-    sys_arch = cons.config.buildconfig.get('config_sys_arch', '"sandbox"')[1:-1]
+    sys_arch = ubman.config.buildconfig.get('config_sys_arch', '"sandbox"')[1:-1]
     return sys_arch == 'sandbox'
 
 @pytest.mark.buildconfigspec('cmd_tpm_v2')
diff --git a/test/py/tests/test_trace.py b/test/py/tests/test_trace.py
index 72f65f2..6ac1b22 100644
--- a/test/py/tests/test_trace.py
+++ b/test/py/tests/test_trace.py
@@ -15,19 +15,19 @@
 RE_LINE = re.compile(r'.*0\.\.\.\.\.? \s*([0-9.]*): func.*[|](\s*)(\S.*)?([{};])$')
 
 
-def collect_trace(cons):
+def collect_trace(ubman):
     """Build U-Boot and run it to collect a trace
 
     Args:
-        cons (ConsoleBase): U-Boot console
+        ubman (ConsoleBase): U-Boot console
 
     Returns:
         tuple:
             str: Filename of the output trace file
             int: Microseconds taken for initf_dm according to bootstage
     """
-    cons.run_command('trace pause')
-    out = cons.run_command('trace stats')
+    ubman.run_command('trace pause')
+    out = ubman.run_command('trace stats')
 
     # The output is something like this:
     #    251,003 function sites
@@ -48,10 +48,10 @@
     assert int(vals['untracked function calls']) == 0
     assert int(vals['maximum observed call depth']) > 30
     assert (vals['call depth limit'] ==
-            cons.config.buildconfig.get('config_trace_call_depth_limit'))
+            ubman.config.buildconfig.get('config_trace_call_depth_limit'))
     assert int(vals['calls not traced due to depth']) > 100000
 
-    out = cons.run_command('bootstage report')
+    out = ubman.run_command('bootstage report')
     # Accumulated time:
     #           19,104  dm_r
     #           23,078  of_live
@@ -62,26 +62,26 @@
     # Read out the trace data
     addr = 0x02000000
     size = 0x02000000
-    out = cons.run_command(f'trace calls {addr:x} {size:x}')
+    out = ubman.run_command(f'trace calls {addr:x} {size:x}')
     print(out)
     fname = os.path.join(TMPDIR, 'trace')
-    out = cons.run_command(
+    out = ubman.run_command(
         'host save hostfs - %x %s ${profoffset}' % (addr, fname))
     return fname, int(dm_f_time[0])
 
 
-def wipe_and_collect_trace(cons):
+def wipe_and_collect_trace(ubman):
     """Pause and wipe traces, return the number of calls (should be zero)
 
     Args:
-        cons (ConsoleBase): U-Boot console
+        ubman (ConsoleBase): U-Boot console
 
     Returns:
         int: the number of traced function calls reported by 'trace stats'
     """
-    cons.run_command('trace pause')
-    cons.run_command('trace wipe')
-    out = cons.run_command('trace stats')
+    ubman.run_command('trace pause')
+    ubman.run_command('trace wipe')
+    out = ubman.run_command('trace stats')
 
     # The output is something like this:
     # 117,221 function sites
@@ -96,22 +96,22 @@
     return int(vals['traced function calls'])
 
 
-def check_function(cons, fname, proftool, map_fname, trace_dat):
+def check_function(ubman, fname, proftool, map_fname, trace_dat):
     """Check that the 'function' output works
 
     Args:
-        cons (ConsoleBase): U-Boot console
+        ubman (ConsoleBase): U-Boot console
         fname (str): Filename of trace file
         proftool (str): Filename of proftool
         map_fname (str): Filename of System.map
         trace_dat (str): Filename of output file
     """
     out = utils.run_and_log(
-        cons, [proftool, '-t', fname, '-o', trace_dat, '-m', map_fname,
+        ubman, [proftool, '-t', fname, '-o', trace_dat, '-m', map_fname,
                'dump-ftrace'])
 
     # Check that trace-cmd can read it
-    out = utils.run_and_log(cons, ['trace-cmd', 'dump', trace_dat])
+    out = utils.run_and_log(ubman, ['trace-cmd', 'dump', trace_dat])
 
     # Tracing meta data in file /tmp/test_trace/trace.dat:
     #    [Initial format]
@@ -140,7 +140,7 @@
 
     # Check that the trace has something useful
     cmd = f"trace-cmd report -l {trace_dat} |grep -E '(initf_|initr_)'"
-    out = utils.run_and_log(cons, ['sh', '-c', cmd])
+    out = utils.run_and_log(ubman, ['sh', '-c', cmd])
 
     # Format:
     #      u-boot-1     0.....    60.805596: function:             initf_malloc
@@ -167,11 +167,11 @@
     assert max_delta < 5
 
 
-def check_funcgraph(cons, fname, proftool, map_fname, trace_dat):
+def check_funcgraph(ubman, fname, proftool, map_fname, trace_dat):
     """Check that the 'funcgraph' output works
 
     Args:
-        cons (ConsoleBase): U-Boot console
+        ubman (ConsoleBase): U-Boot console
         fname (str): Filename of trace file
         proftool (str): Filename of proftool
         map_fname (str): Filename of System.map
@@ -183,12 +183,12 @@
 
     # Generate the funcgraph format
     out = utils.run_and_log(
-        cons, [proftool, '-t', fname, '-o', trace_dat, '-m', map_fname,
+        ubman, [proftool, '-t', fname, '-o', trace_dat, '-m', map_fname,
                'dump-ftrace', '-f', 'funcgraph'])
 
     # Check that the trace has what we expect
     cmd = f'trace-cmd report -l {trace_dat} |head -n 70'
-    out = utils.run_and_log(cons, ['sh', '-c', cmd])
+    out = utils.run_and_log(ubman, ['sh', '-c', cmd])
 
     # First look for this:
     #  u-boot-1     0.....   282.101360: funcgraph_entry:        0.004 us   |    initf_malloc();
@@ -230,7 +230,7 @@
     # Now look for initf_dm() and dm_timer_init() so we can check the bootstage
     # time
     cmd = f"trace-cmd report -l {trace_dat} |grep -E '(initf_dm|dm_timer_init)'"
-    out = utils.run_and_log(cons, ['sh', '-c', cmd])
+    out = utils.run_and_log(ubman, ['sh', '-c', cmd])
 
     start_timestamp = None
     end_timestamp = None
@@ -249,14 +249,14 @@
     return int((float(end_timestamp) - float(start_timestamp)) * 1000000)
 
 
-def check_flamegraph(cons, fname, proftool, map_fname, trace_fg):
+def check_flamegraph(ubman, fname, proftool, map_fname, trace_fg):
     """Check that the 'flamegraph' output works
 
     This spot checks a few call counts and estimates the time taken by the
     initf_dm() function
 
     Args:
-        cons (ConsoleBase): U-Boot console
+        ubman (ConsoleBase): U-Boot console
         fname (str): Filename of trace file
         proftool (str): Filename of proftool
         map_fname (str): Filename of System.map
@@ -268,7 +268,7 @@
 
     # Generate the flamegraph format
     out = utils.run_and_log(
-        cons, [proftool, '-t', fname, '-o', trace_fg, '-m', map_fname,
+        ubman, [proftool, '-t', fname, '-o', trace_fg, '-m', map_fname,
                'dump-flamegraph'])
 
     # We expect dm_timer_init() to be called twice: once before relocation and
@@ -285,7 +285,7 @@
 
     # Generate the timing graph
     utils.run_and_log(
-        cons, [proftool, '-t', fname, '-o', trace_fg, '-m', map_fname,
+        ubman, [proftool, '-t', fname, '-o', trace_fg, '-m', map_fname,
                'dump-flamegraph', '-f', 'timing'])
 
     # Add up all the time spend in initf_dm() and its children
@@ -305,26 +305,25 @@
 @pytest.mark.buildconfigspec('trace')
 def test_trace(ubman):
     """Test we can build sandbox with trace, collect and process a trace"""
-    cons = ubman
 
     if not os.path.exists(TMPDIR):
         os.mkdir(TMPDIR)
-    proftool = os.path.join(cons.config.build_dir, 'tools', 'proftool')
-    map_fname = os.path.join(cons.config.build_dir, 'System.map')
+    proftool = os.path.join(ubman.config.build_dir, 'tools', 'proftool')
+    map_fname = os.path.join(ubman.config.build_dir, 'System.map')
     trace_dat = os.path.join(TMPDIR, 'trace.dat')
     trace_fg = os.path.join(TMPDIR, 'trace.fg')
 
-    fname, dm_f_time = collect_trace(cons)
+    fname, dm_f_time = collect_trace(ubman)
 
-    check_function(cons, fname, proftool, map_fname, trace_dat)
-    trace_time = check_funcgraph(cons, fname, proftool, map_fname, trace_dat)
+    check_function(ubman, fname, proftool, map_fname, trace_dat)
+    trace_time = check_funcgraph(ubman, fname, proftool, map_fname, trace_dat)
 
     # Check that bootstage and funcgraph agree to within 10 microseconds
     diff = abs(trace_time - dm_f_time)
     print(f'trace_time {trace_time}, dm_f_time {dm_f_time}')
     assert diff / dm_f_time < 0.01
 
-    fg_time = check_flamegraph(cons, fname, proftool, map_fname, trace_fg)
+    fg_time = check_flamegraph(ubman, fname, proftool, map_fname, trace_fg)
 
     # Check that bootstage and flamegraph agree to within 30%
     # This allows for CI being slow to run
@@ -332,5 +331,5 @@
     assert diff / dm_f_time < 0.3
 
     # Check that the trace buffer can be wiped
-    numcalls = wipe_and_collect_trace(cons)
+    numcalls = wipe_and_collect_trace(ubman)
     assert numcalls == 0
diff --git a/test/py/tests/test_upl.py b/test/py/tests/test_upl.py
index c8eeaa0..c79c32a 100644
--- a/test/py/tests/test_upl.py
+++ b/test/py/tests/test_upl.py
@@ -19,20 +19,19 @@
     The entire FIT is loaded into memory in SPL (in upl_load_from_image()) so
     that it can be inspected in upl_test_info_norun
     """
-    cons = ubman
-    ram = os.path.join(cons.config.build_dir, 'ram.bin')
-    fdt = os.path.join(cons.config.build_dir, 'u-boot.dtb')
+    ram = os.path.join(ubman.config.build_dir, 'ram.bin')
+    fdt = os.path.join(ubman.config.build_dir, 'u-boot.dtb')
 
     # Remove any existing RAM file, so we don't have old data present
     if os.path.exists(ram):
         os.remove(ram)
     flags = ['-m', ram, '-d', fdt, '--upl']
-    cons.restart_uboot_with_flags(flags, use_dtb=False)
+    ubman.restart_uboot_with_flags(flags, use_dtb=False)
 
     # Make sure that Universal Payload is detected in U-Boot proper
-    output = cons.run_command('upl info')
+    output = ubman.run_command('upl info')
     assert 'UPL state: active' == output
 
     # Check the FIT offsets look correct
-    output = cons.run_command('ut upl -f upl_test_info_norun')
+    output = ubman.run_command('ut upl -f upl_test_info_norun')
     assert 'failures: 0' in output
diff --git a/test/py/tests/test_ut.py b/test/py/tests/test_ut.py
index d7cf95d..ea0c43c 100644
--- a/test/py/tests/test_ut.py
+++ b/test/py/tests/test_ut.py
@@ -27,12 +27,12 @@
     if not os.path.exists(dirname):
         os.mkdir(dirname)
 
-def setup_image(cons, devnum, part_type, img_size=20, second_part=False,
+def setup_image(ubman, devnum, part_type, img_size=20, second_part=False,
                 basename='mmc'):
     """Create a disk image with a single partition
 
     Args:
-        cons (ConsoleBase): Console to use
+        ubman (ConsoleBase): Console to use
         devnum (int): Device number to use, e.g. 1
         part_type (int): Partition type, e.g. 0xc for FAT32
         img_size (int): Image size in MiB
@@ -44,26 +44,26 @@
             str: Filename of MMC image
             str: Directory name of scratch directory
     """
-    fname = os.path.join(cons.config.source_dir, f'{basename}{devnum}.img')
-    mnt = os.path.join(cons.config.persistent_data_dir, 'scratch')
+    fname = os.path.join(ubman.config.source_dir, f'{basename}{devnum}.img')
+    mnt = os.path.join(ubman.config.persistent_data_dir, 'scratch')
     mkdir_cond(mnt)
 
     spec = f'type={part_type:x}, size={img_size - 2}M, start=1M, bootable'
     if second_part:
         spec += '\ntype=c'
 
-    utils.run_and_log(cons, f'qemu-img create {fname} 20M')
-    utils.run_and_log(cons, f'sfdisk {fname}',
+    utils.run_and_log(ubman, f'qemu-img create {fname} 20M')
+    utils.run_and_log(ubman, f'sfdisk {fname}',
                              stdin=spec.encode('utf-8'))
     return fname, mnt
 
-def setup_bootmenu_image(cons):
+def setup_bootmenu_image(ubman):
     """Create a 20MB disk image with a single ext4 partition
 
     This is modelled on Armbian 22.08 Jammy
     """
     mmc_dev = 4
-    fname, mnt = setup_image(cons, mmc_dev, 0x83)
+    fname, mnt = setup_image(ubman, mmc_dev, 0x83)
 
     script = '''# DO NOT EDIT THIS FILE
 #
@@ -146,16 +146,16 @@
     with open(cmd_fname, 'w', encoding='ascii') as outf:
         print(script, file=outf)
 
-    infname = os.path.join(cons.config.source_dir,
+    infname = os.path.join(ubman.config.source_dir,
                             'test/py/tests/bootstd/armbian.bmp.xz')
     bmp_file = os.path.join(bootdir, 'boot.bmp')
     utils.run_and_log(
-        cons,
+        ubman,
         ['sh', '-c', f'xz -dc {infname} >{bmp_file}'])
 
-    mkimage = cons.config.build_dir + '/tools/mkimage'
+    mkimage = ubman.config.build_dir + '/tools/mkimage'
     utils.run_and_log(
-        cons, f'{mkimage} -C none -A arm -T script -d {cmd_fname} {scr_fname}')
+        ubman, f'{mkimage} -C none -A arm -T script -d {cmd_fname} {scr_fname}')
 
     kernel = 'vmlinuz-5.15.63-rockchip64'
     target = os.path.join(bootdir, kernel)
@@ -166,20 +166,20 @@
     if os.path.exists(symlink):
         os.remove(symlink)
     utils.run_and_log(
-        cons, f'echo here {kernel} {symlink}')
+        ubman, f'echo here {kernel} {symlink}')
     os.symlink(kernel, symlink)
 
     fsfile = 'ext18M.img'
-    utils.run_and_log(cons, f'fallocate -l 18M {fsfile}')
-    utils.run_and_log(cons, f'mkfs.ext4 {fsfile} -d {mnt}')
-    utils.run_and_log(cons, f'dd if={fsfile} of={fname} bs=1M seek=1')
-    utils.run_and_log(cons, f'rm -rf {mnt}')
-    utils.run_and_log(cons, f'rm -f {fsfile}')
+    utils.run_and_log(ubman, f'fallocate -l 18M {fsfile}')
+    utils.run_and_log(ubman, f'mkfs.ext4 {fsfile} -d {mnt}')
+    utils.run_and_log(ubman, f'dd if={fsfile} of={fname} bs=1M seek=1')
+    utils.run_and_log(ubman, f'rm -rf {mnt}')
+    utils.run_and_log(ubman, f'rm -f {fsfile}')
 
-def setup_bootflow_image(cons):
+def setup_bootflow_image(ubman):
     """Create a 20MB disk image with a single FAT partition"""
     mmc_dev = 1
-    fname, mnt = setup_image(cons, mmc_dev, 0xc, second_part=True)
+    fname, mnt = setup_image(ubman, mmc_dev, 0xc, second_part=True)
 
     vmlinux = 'vmlinuz-5.3.7-301.fc31.armv7hl'
     initrd = 'initramfs-5.3.7-301.fc31.armv7hl.img'
@@ -204,12 +204,12 @@
     with open(conf, 'w', encoding='ascii') as fd:
         print(script, file=fd)
 
-    inf = os.path.join(cons.config.persistent_data_dir, 'inf')
+    inf = os.path.join(ubman.config.persistent_data_dir, 'inf')
     with open(inf, 'wb') as fd:
         fd.write(gzip.compress(b'vmlinux'))
-    mkimage = cons.config.build_dir + '/tools/mkimage'
+    mkimage = ubman.config.build_dir + '/tools/mkimage'
     utils.run_and_log(
-        cons, f'{mkimage} -f auto -d {inf} {os.path.join(mnt, vmlinux)}')
+        ubman, f'{mkimage} -f auto -d {inf} {os.path.join(mnt, vmlinux)}')
 
     with open(os.path.join(mnt, initrd), 'w', encoding='ascii') as fd:
         print('initrd', file=fd)
@@ -218,27 +218,27 @@
 
     dtb_file = os.path.join(mnt, f'{dtbdir}/sandbox.dtb')
     utils.run_and_log(
-        cons, f'dtc -o {dtb_file}', stdin=b'/dts-v1/; / {};')
+        ubman, f'dtc -o {dtb_file}', stdin=b'/dts-v1/; / {};')
 
     fsfile = 'vfat18M.img'
-    utils.run_and_log(cons, f'fallocate -l 18M {fsfile}')
-    utils.run_and_log(cons, f'mkfs.vfat {fsfile}')
-    utils.run_and_log(cons, ['sh', '-c', f'mcopy -i {fsfile} {mnt}/* ::/'])
-    utils.run_and_log(cons, f'dd if={fsfile} of={fname} bs=1M seek=1')
-    utils.run_and_log(cons, f'rm -rf {mnt}')
-    utils.run_and_log(cons, f'rm -f {fsfile}')
+    utils.run_and_log(ubman, f'fallocate -l 18M {fsfile}')
+    utils.run_and_log(ubman, f'mkfs.vfat {fsfile}')
+    utils.run_and_log(ubman, ['sh', '-c', f'mcopy -i {fsfile} {mnt}/* ::/'])
+    utils.run_and_log(ubman, f'dd if={fsfile} of={fname} bs=1M seek=1')
+    utils.run_and_log(ubman, f'rm -rf {mnt}')
+    utils.run_and_log(ubman, f'rm -f {fsfile}')
 
-def setup_cros_image(cons):
+def setup_cros_image(ubman):
     """Create a 20MB disk image with ChromiumOS partitions"""
     Partition = collections.namedtuple('part', 'start,size,name')
     parts = {}
     disk_data = None
 
-    def pack_kernel(cons, arch, kern, dummy):
+    def pack_kernel(ubman, arch, kern, dummy):
         """Pack a kernel containing some fake data
 
         Args:
-            cons (ConsoleBase): Console to use
+            ubman (ConsoleBase): Console to use
             arch (str): Architecture to use ('x86' or 'arm')
             kern (str): Filename containing kernel
             dummy (str): Dummy filename to use for config and bootloader
@@ -246,10 +246,10 @@
         Return:
             bytes: Packed-kernel data
         """
-        kern_part = os.path.join(cons.config.result_dir,
+        kern_part = os.path.join(ubman.config.result_dir,
                                  f'kern-part-{arch}.bin')
         utils.run_and_log(
-            cons,
+            ubman,
             f'futility vbutil_kernel --pack {kern_part} '
             '--keyblock doc/chromium/files/devkeys/kernel.keyblock '
             '--signprivate doc/chromium/files/devkeys/kernel_data_key.vbprivk '
@@ -275,9 +275,9 @@
         disk_data = disk_data[:start] + data + disk_data[start + len(data):]
 
     mmc_dev = 5
-    fname = os.path.join(cons.config.source_dir, f'mmc{mmc_dev}.img')
-    utils.run_and_log(cons, f'qemu-img create {fname} 20M')
-    utils.run_and_log(cons, f'cgpt create {fname}')
+    fname = os.path.join(ubman.config.source_dir, f'mmc{mmc_dev}.img')
+    utils.run_and_log(ubman, f'qemu-img create {fname} 20M')
+    utils.run_and_log(ubman, f'cgpt create {fname}')
 
     uuid_state = 'ebd0a0a2-b9e5-4433-87c0-68b6b72699c7'
     uuid_kern = 'fe3a2a5d-4f32-41a7-b725-accc3285a309'
@@ -317,12 +317,12 @@
         else:
             size = int(size_str)
         utils.run_and_log(
-            cons,
+            ubman,
             f"cgpt add -i {part['num']} -b {ptr} -s {size} -t {part['type']} {fname}")
         ptr += size
 
-    utils.run_and_log(cons, f'cgpt boot -p {fname}')
-    out = utils.run_and_log(cons, f'cgpt show -q {fname}')
+    utils.run_and_log(ubman, f'cgpt boot -p {fname}')
+    out = utils.run_and_log(ubman, f'cgpt show -q {fname}')
 
     # We expect something like this:
     #   8239        2048       1  Basic data
@@ -344,14 +344,14 @@
         parts[int(num)] = Partition(int(start), int(size), name)
 
     # Set up the kernel command-line
-    dummy = os.path.join(cons.config.result_dir, 'dummy.txt')
+    dummy = os.path.join(ubman.config.result_dir, 'dummy.txt')
     with open(dummy, 'wb') as outf:
         outf.write(b'BOOT_IMAGE=/vmlinuz-5.15.0-121-generic root=/dev/nvme0n1p1 ro quiet splash vt.handoff=7')
 
     # For now we just use dummy kernels. This limits testing to just detecting
     # a signed kernel. We could add support for the x86 data structures so that
     # testing could cover getting the cmdline, setup.bin and other pieces.
-    kern = os.path.join(cons.config.result_dir, 'kern.bin')
+    kern = os.path.join(ubman.config.result_dir, 'kern.bin')
     with open(kern, 'wb') as outf:
         outf.write(b'kernel\n')
 
@@ -359,15 +359,15 @@
         disk_data = inf.read()
 
     # put x86 kernel in partition 2 and arm one in partition 4
-    set_part_data(2, pack_kernel(cons, 'x86', kern, dummy))
-    set_part_data(4, pack_kernel(cons, 'arm', kern, dummy))
+    set_part_data(2, pack_kernel(ubman, 'x86', kern, dummy))
+    set_part_data(4, pack_kernel(ubman, 'arm', kern, dummy))
 
     with open(fname, 'wb') as outf:
         outf.write(disk_data)
 
     return fname
 
-def setup_android_image(cons):
+def setup_android_image(ubman):
     """Create a 20MB disk image with Android partitions"""
     Partition = collections.namedtuple('part', 'start,size,name')
     parts = {}
@@ -388,9 +388,9 @@
         disk_data = disk_data[:start] + data + disk_data[start + len(data):]
 
     mmc_dev = 7
-    fname = os.path.join(cons.config.source_dir, f'mmc{mmc_dev}.img')
-    utils.run_and_log(cons, f'qemu-img create {fname} 20M')
-    utils.run_and_log(cons, f'cgpt create {fname}')
+    fname = os.path.join(ubman.config.source_dir, f'mmc{mmc_dev}.img')
+    utils.run_and_log(ubman, f'qemu-img create {fname} 20M')
+    utils.run_and_log(ubman, f'cgpt create {fname}')
 
     ptr = 40
 
@@ -413,12 +413,12 @@
         else:
             size = int(size_str)
         utils.run_and_log(
-            cons,
+            ubman,
             f"cgpt add -i {part['num']} -b {ptr} -s {size} -l {part['label']} -t basicdata {fname}")
         ptr += size
 
-    utils.run_and_log(cons, f'cgpt boot -p {fname}')
-    out = utils.run_and_log(cons, f'cgpt show -q {fname}')
+    utils.run_and_log(ubman, f'cgpt boot -p {fname}')
+    out = utils.run_and_log(ubman, f'cgpt show -q {fname}')
 
     # Create a dict (indexed by partition number) containing the above info
     for line in out.splitlines():
@@ -428,13 +428,13 @@
     with open(fname, 'rb') as inf:
         disk_data = inf.read()
 
-    test_abootimg.AbootimgTestDiskImage(cons, 'bootv4.img', test_abootimg.boot_img_hex)
-    boot_img = os.path.join(cons.config.result_dir, 'bootv4.img')
+    test_abootimg.AbootimgTestDiskImage(ubman, 'bootv4.img', test_abootimg.boot_img_hex)
+    boot_img = os.path.join(ubman.config.result_dir, 'bootv4.img')
     with open(boot_img, 'rb') as inf:
         set_part_data(2, inf.read())
 
-    test_abootimg.AbootimgTestDiskImage(cons, 'vendor_boot.img', test_abootimg.vboot_img_hex)
-    vendor_boot_img = os.path.join(cons.config.result_dir, 'vendor_boot.img')
+    test_abootimg.AbootimgTestDiskImage(ubman, 'vendor_boot.img', test_abootimg.vboot_img_hex)
+    vendor_boot_img = os.path.join(ubman.config.result_dir, 'vendor_boot.img')
     with open(vendor_boot_img, 'rb') as inf:
         set_part_data(4, inf.read())
 
@@ -444,9 +444,9 @@
     print(f'wrote to {fname}')
 
     mmc_dev = 8
-    fname = os.path.join(cons.config.source_dir, f'mmc{mmc_dev}.img')
-    utils.run_and_log(cons, f'qemu-img create {fname} 20M')
-    utils.run_and_log(cons, f'cgpt create {fname}')
+    fname = os.path.join(ubman.config.source_dir, f'mmc{mmc_dev}.img')
+    utils.run_and_log(ubman, f'qemu-img create {fname} 20M')
+    utils.run_and_log(ubman, f'cgpt create {fname}')
 
     ptr = 40
 
@@ -467,12 +467,12 @@
         else:
             size = int(size_str)
         utils.run_and_log(
-            cons,
+            ubman,
             f"cgpt add -i {part['num']} -b {ptr} -s {size} -l {part['label']} -t basicdata {fname}")
         ptr += size
 
-    utils.run_and_log(cons, f'cgpt boot -p {fname}')
-    out = utils.run_and_log(cons, f'cgpt show -q {fname}')
+    utils.run_and_log(ubman, f'cgpt boot -p {fname}')
+    out = utils.run_and_log(ubman, f'cgpt show -q {fname}')
 
     # Create a dict (indexed by partition number) containing the above info
     for line in out.splitlines():
@@ -482,8 +482,8 @@
     with open(fname, 'rb') as inf:
         disk_data = inf.read()
 
-    test_abootimg.AbootimgTestDiskImage(cons, 'boot.img', test_abootimg.img_hex)
-    boot_img = os.path.join(cons.config.result_dir, 'boot.img')
+    test_abootimg.AbootimgTestDiskImage(ubman, 'boot.img', test_abootimg.img_hex)
+    boot_img = os.path.join(ubman.config.result_dir, 'boot.img')
     with open(boot_img, 'rb') as inf:
         set_part_data(2, inf.read())
 
@@ -494,16 +494,16 @@
 
     return fname
 
-def setup_cedit_file(cons):
+def setup_cedit_file(ubman):
     """Set up a .dtb file for use with testing expo and configuration editor"""
-    infname = os.path.join(cons.config.source_dir,
+    infname = os.path.join(ubman.config.source_dir,
                            'test/boot/files/expo_layout.dts')
-    inhname = os.path.join(cons.config.source_dir,
+    inhname = os.path.join(ubman.config.source_dir,
                            'test/boot/files/expo_ids.h')
-    expo_tool = os.path.join(cons.config.source_dir, 'tools/expo.py')
+    expo_tool = os.path.join(ubman.config.source_dir, 'tools/expo.py')
     outfname = 'cedit.dtb'
     utils.run_and_log(
-        cons, f'{expo_tool} -e {inhname} -l {infname} -o {outfname}')
+        ubman, f'{expo_tool} -e {inhname} -l {infname} -o {outfname}')
 
 @pytest.mark.buildconfigspec('ut_dm')
 def test_ut_dm_init(ubman):
@@ -541,30 +541,30 @@
         fh.write(data)
 
 
-def setup_efi_image(cons):
+def setup_efi_image(ubman):
     """Create a 20MB disk image with an EFI app on it"""
     devnum = 1
     basename = 'flash'
-    fname, mnt = setup_image(cons, devnum, 0xc, second_part=True,
+    fname, mnt = setup_image(ubman, devnum, 0xc, second_part=True,
                              basename=basename)
 
     efi_dir = os.path.join(mnt, 'EFI')
     mkdir_cond(efi_dir)
     bootdir = os.path.join(efi_dir, 'BOOT')
     mkdir_cond(bootdir)
-    efi_src = os.path.join(cons.config.build_dir,
+    efi_src = os.path.join(ubman.config.build_dir,
                         'lib/efi_loader/testapp.efi')
     efi_dst = os.path.join(bootdir, 'BOOTSBOX.EFI')
     with open(efi_src, 'rb') as inf:
         with open(efi_dst, 'wb') as outf:
             outf.write(inf.read())
     fsfile = 'vfat18M.img'
-    utils.run_and_log(cons, f'fallocate -l 18M {fsfile}')
-    utils.run_and_log(cons, f'mkfs.vfat {fsfile}')
-    utils.run_and_log(cons, ['sh', '-c', f'mcopy -vs -i {fsfile} {mnt}/* ::/'])
-    utils.run_and_log(cons, f'dd if={fsfile} of={fname} bs=1M seek=1')
-    utils.run_and_log(cons, f'rm -rf {mnt}')
-    utils.run_and_log(cons, f'rm -f {fsfile}')
+    utils.run_and_log(ubman, f'fallocate -l 18M {fsfile}')
+    utils.run_and_log(ubman, f'mkfs.vfat {fsfile}')
+    utils.run_and_log(ubman, ['sh', '-c', f'mcopy -vs -i {fsfile} {mnt}/* ::/'])
+    utils.run_and_log(ubman, f'dd if={fsfile} of={fname} bs=1M seek=1')
+    utils.run_and_log(ubman, f'rm -rf {mnt}')
+    utils.run_and_log(ubman, f'rm -f {fsfile}')
 
 @pytest.mark.buildconfigspec('cmd_bootflow')
 @pytest.mark.buildconfigspec('sandbox')
diff --git a/test/py/tests/test_vbe.py b/test/py/tests/test_vbe.py
index 876d22f..a1f32f3 100644
--- a/test/py/tests/test_vbe.py
+++ b/test/py/tests/test_vbe.py
@@ -91,10 +91,9 @@
 @pytest.mark.boardspec('sandbox_flattree')
 @pytest.mark.requiredtool('dtc')
 def test_vbe(ubman):
-    cons = ubman
-    kernel = fit_util.make_kernel(cons, 'vbe-kernel.bin', 'kernel')
-    fdt = fit_util.make_dtb(cons, base_fdt, 'vbe-fdt')
-    fdt_out = fit_util.make_fname(cons, 'fdt-out.dtb')
+    kernel = fit_util.make_kernel(ubman, 'vbe-kernel.bin', 'kernel')
+    fdt = fit_util.make_dtb(ubman, base_fdt, 'vbe-fdt')
+    fdt_out = fit_util.make_fname(ubman, 'fdt-out.dtb')
 
     params = {
         'fit_addr' : 0x1000,
@@ -108,13 +107,13 @@
 
         'compression' : 'none',
     }
-    mkimage = cons.config.build_dir + '/tools/mkimage'
-    fit = fit_util.make_fit(cons, mkimage, base_its, params, 'test-vbe.fit',
+    mkimage = ubman.config.build_dir + '/tools/mkimage'
+    fit = fit_util.make_fit(ubman, mkimage, base_its, params, 'test-vbe.fit',
                             base_fdt)
     params['fit'] = fit
     cmd = base_script % params
 
-    with cons.log.section('Kernel load'):
-        output = cons.run_command_list(cmd.splitlines())
+    with ubman.log.section('Kernel load'):
+        output = ubman.run_command_list(cmd.splitlines())
 
     assert 'failures: 0' in output[-1]
diff --git a/test/py/tests/test_vbe_vpl.py b/test/py/tests/test_vbe_vpl.py
index 317a324..f011b03 100644
--- a/test/py/tests/test_vbe_vpl.py
+++ b/test/py/tests/test_vbe_vpl.py
@@ -11,30 +11,29 @@
 @pytest.mark.boardspec('sandbox_vpl')
 @pytest.mark.requiredtool('dtc')
 def test_vbe_vpl(ubman):
-    cons = ubman
-    #cmd = [cons.config.build_dir + fname, '-v']
-    ram = os.path.join(cons.config.build_dir, 'ram.bin')
-    fdt = os.path.join(cons.config.build_dir, 'arch/sandbox/dts/test.dtb')
-    image_fname = os.path.join(cons.config.build_dir, 'image.bin')
+    #cmd = [ubman.config.build_dir + fname, '-v']
+    ram = os.path.join(ubman.config.build_dir, 'ram.bin')
+    fdt = os.path.join(ubman.config.build_dir, 'arch/sandbox/dts/test.dtb')
+    image_fname = os.path.join(ubman.config.build_dir, 'image.bin')
 
     # Enable firmware1 and the mmc that it uses. These are needed for the full
     # VBE flow.
     utils.run_and_log(
-        cons, f'fdtput -t s {fdt} /bootstd/firmware0 status disabled')
+        ubman, f'fdtput -t s {fdt} /bootstd/firmware0 status disabled')
     utils.run_and_log(
-        cons, f'fdtput -t s {fdt} /bootstd/firmware1 status okay')
+        ubman, f'fdtput -t s {fdt} /bootstd/firmware1 status okay')
     utils.run_and_log(
-        cons, f'fdtput -t s {fdt} /mmc3 status okay')
+        ubman, f'fdtput -t s {fdt} /mmc3 status okay')
     utils.run_and_log(
-        cons, f'fdtput -t s {fdt} /mmc3 filename {image_fname}')
+        ubman, f'fdtput -t s {fdt} /mmc3 filename {image_fname}')
 
     # Remove any existing RAM file, so we don't have old data present
     if os.path.exists(ram):
         os.remove(ram)
     flags = ['-p', image_fname, '-w', '-s', 'state.dtb']
-    cons.restart_uboot_with_flags(flags)
+    ubman.restart_uboot_with_flags(flags)
 
     # Make sure that VBE was used in both VPL (to load SPL) and SPL (to load
     # U-Boot
-    output = cons.run_command('vbe state')
+    output = ubman.run_command('vbe state')
     assert output == 'Phases: VPL SPL'
diff --git a/test/py/tests/test_vboot.py b/test/py/tests/test_vboot.py
index 2b29871..7a7f9c3 100644
--- a/test/py/tests/test_vboot.py
+++ b/test/py/tests/test_vboot.py
@@ -47,7 +47,7 @@
 import vboot_evil
 
 # Common helper functions
-def dtc(dts, cons, dtc_args, datadir, tmpdir, dtb):
+def dtc(dts, ubman, dtc_args, datadir, tmpdir, dtb):
     """Run the device tree compiler to compile a .dts file
 
     The output file will be the same as the input file but with a .dtb
@@ -55,30 +55,30 @@
 
     Args:
         dts: Device tree file to compile.
-        cons: U-Boot console.
+        ubman: U-Boot console.
         dtc_args: DTC arguments.
         datadir: Path to data directory.
         tmpdir: Path to temp directory.
         dtb: Resulting DTB file.
     """
     dtb = dts.replace('.dts', '.dtb')
-    utils.run_and_log(cons, 'dtc %s %s%s -O dtb '
+    utils.run_and_log(ubman, 'dtc %s %s%s -O dtb '
                       '-o %s%s' % (dtc_args, datadir, dts, tmpdir, dtb))
 
-def make_fit(its, cons, mkimage, dtc_args, datadir, fit):
+def make_fit(its, ubman, mkimage, dtc_args, datadir, fit):
     """Make a new FIT from the .its source file.
 
     This runs 'mkimage -f' to create a new FIT.
 
     Args:
         its: Filename containing .its source.
-        cons: U-Boot console.
+        ubman: U-Boot console.
         mkimage: Path to mkimage utility.
         dtc_args: DTC arguments.
         datadir: Path to data directory.
         fit: Resulting FIT file.
     """
-    utils.run_and_log(cons, [mkimage, '-D', dtc_args, '-f',
+    utils.run_and_log(ubman, [mkimage, '-D', dtc_args, '-f',
                              '%s%s' % (datadir, its), fit])
 
 # Only run the full suite on a few combinations, since it doesn't add any more
@@ -134,7 +134,7 @@
             options: Options provided to the compiler.
         """
         dtb = dts.replace('.dts', '.dtb')
-        utils.run_and_log(cons, 'dtc %s %s%s -O dtb -o %s%s %s' %
+        utils.run_and_log(ubman, 'dtc %s %s%s -O dtb -o %s%s %s' %
                           (dtc_args, datadir, dts, tmpdir, dtb, options))
 
     def run_binman(dtb):
@@ -145,7 +145,7 @@
         """
         pythonpath = os.environ.get('PYTHONPATH', '')
         os.environ['PYTHONPATH'] = pythonpath + ':' + '%s/../scripts/dtc/pylibfdt' % tmpdir
-        utils.run_and_log(cons, [binman, 'build', '-d', "%s/%s" % (tmpdir,dtb),
+        utils.run_and_log(ubman, [binman, 'build', '-d', "%s/%s" % (tmpdir,dtb),
                                  '-a', "pre-load-key-path=%s" % tmpdir, '-O',
                                  tmpdir, '-I', tmpdir])
         os.environ['PYTHONPATH'] = pythonpath
@@ -167,9 +167,9 @@
         """
         if not fit:
             fit = '%stest.fit' % tmpdir
-        cons.restart_uboot()
-        with cons.log.section('Verified boot %s %s' % (sha_algo, test_type)):
-            output = cons.run_command_list(
+        ubman.restart_uboot()
+        with ubman.log.section('Verified boot %s %s' % (sha_algo, test_type)):
+            output = ubman.run_command_list(
                 ['host load hostfs - 100 %s' % fit,
                  'fdt addr 100',
                  'bootm 100'])
@@ -194,8 +194,8 @@
         args = [mkimage, '-F', '-k', tmpdir, '-K', dtb, '-r', fit]
         if options:
             args += options.split(' ')
-        cons.log.action('%s: Sign images' % sha_algo)
-        utils.run_and_log(cons, args)
+        ubman.log.action('%s: Sign images' % sha_algo)
+        utils.run_and_log(ubman, args)
 
     def sign_fit_dtb(sha_algo, options, dtb):
         """Sign the FIT
@@ -211,8 +211,8 @@
         args = [mkimage, '-F', '-k', tmpdir, '-K', dtb, '-r', fit]
         if options:
             args += options.split(' ')
-        cons.log.action('%s: Sign images' % sha_algo)
-        utils.run_and_log(cons, args)
+        ubman.log.action('%s: Sign images' % sha_algo)
+        utils.run_and_log(ubman, args)
 
     def sign_fit_norequire(sha_algo, options):
         """Sign the FIT
@@ -228,8 +228,8 @@
         args = [mkimage, '-F', '-k', tmpdir, '-K', dtb, fit]
         if options:
             args += options.split(' ')
-        cons.log.action('%s: Sign images' % sha_algo)
-        utils.run_and_log(cons, args)
+        ubman.log.action('%s: Sign images' % sha_algo)
+        utils.run_and_log(ubman, args)
 
     def replace_fit_totalsize(size):
         """Replace FIT header's totalsize with something greater.
@@ -278,13 +278,13 @@
         else:
             rsa_keygen_bits = 2048
 
-        utils.run_and_log(cons, 'openssl genpkey -algorithm RSA -out %s%s.key '
+        utils.run_and_log(ubman, 'openssl genpkey -algorithm RSA -out %s%s.key '
                      '-pkeyopt rsa_keygen_bits:%d '
                      '-pkeyopt rsa_keygen_pubexp:%d' %
                      (tmpdir, name, rsa_keygen_bits, public_exponent))
 
         # Create a certificate containing the public key
-        utils.run_and_log(cons, 'openssl req -batch -new -x509 -key %s%s.key '
+        utils.run_and_log(ubman, 'openssl req -batch -new -x509 -key %s%s.key '
                           '-out %s%s.crt' % (tmpdir, name, tmpdir, name))
 
     def test_with_algo(sha_algo, padding, sign_options):
@@ -303,12 +303,12 @@
         # Compile our device tree files for kernel and U-Boot. These are
         # regenerated here since mkimage will modify them (by adding a
         # public key) below.
-        dtc('sandbox-kernel.dts', cons, dtc_args, datadir, tmpdir, dtb)
-        dtc('sandbox-u-boot.dts', cons, dtc_args, datadir, tmpdir, dtb)
+        dtc('sandbox-kernel.dts', ubman, dtc_args, datadir, tmpdir, dtb)
+        dtc('sandbox-u-boot.dts', ubman, dtc_args, datadir, tmpdir, dtb)
 
         # Build the FIT, but don't sign anything yet
-        cons.log.action('%s: Test FIT with signed images' % sha_algo)
-        make_fit('sign-images-%s%s.its' % (sha_algo, padding), cons, mkimage, dtc_args, datadir, fit)
+        ubman.log.action('%s: Test FIT with signed images' % sha_algo)
+        make_fit('sign-images-%s%s.its' % (sha_algo, padding), ubman, mkimage, dtc_args, datadir, fit)
         run_bootm(sha_algo, 'unsigned images', ' - OK' if algo_arg else 'dev-', True)
 
         # Sign images with our dev keys
@@ -316,19 +316,19 @@
         run_bootm(sha_algo, 'signed images', 'dev+', True)
 
         # Create a fresh .dtb without the public keys
-        dtc('sandbox-u-boot.dts', cons, dtc_args, datadir, tmpdir, dtb)
+        dtc('sandbox-u-boot.dts', ubman, dtc_args, datadir, tmpdir, dtb)
 
-        cons.log.action('%s: Test FIT with signed configuration' % sha_algo)
-        make_fit('sign-configs-%s%s.its' % (sha_algo, padding), cons, mkimage, dtc_args, datadir, fit)
+        ubman.log.action('%s: Test FIT with signed configuration' % sha_algo)
+        make_fit('sign-configs-%s%s.its' % (sha_algo, padding), ubman, mkimage, dtc_args, datadir, fit)
         run_bootm(sha_algo, 'unsigned config', '%s+ OK' % ('sha256' if algo_arg else sha_algo), True)
 
         # Sign images with our dev keys
         sign_fit(sha_algo, sign_options)
         run_bootm(sha_algo, 'signed config', 'dev+', True)
 
-        cons.log.action('%s: Check signed config on the host' % sha_algo)
+        ubman.log.action('%s: Check signed config on the host' % sha_algo)
 
-        utils.run_and_log(cons, [fit_check_sign, '-f', fit, '-k', dtb])
+        utils.run_and_log(ubman, [fit_check_sign, '-f', fit, '-k', dtb])
 
         if full_test:
             # Make sure that U-Boot checks that the config is in the list of
@@ -341,7 +341,7 @@
             with open(ffit, 'w+b') as fd:
                 vboot_forge.write_fdt(root, strblock, fd)
             utils.run_and_log_expect_exception(
-                cons, [fit_check_sign, '-f', ffit, '-k', dtb],
+                ubman, [fit_check_sign, '-f', ffit, '-k', dtb],
                 1, 'Failed to verify required signature')
 
             run_bootm(sha_algo, 'forged config', 'Bad Data Hash', False, ffit)
@@ -352,7 +352,7 @@
             vboot_evil.add_evil_node(fit, efit, evil_kernel, 'fakeroot')
 
             utils.run_and_log_expect_exception(
-                cons, [fit_check_sign, '-f', efit, '-k', dtb],
+                ubman, [fit_check_sign, '-f', efit, '-k', dtb],
                 1, 'Failed to verify required signature')
             run_bootm(sha_algo, 'evil fakeroot', 'Bad FIT kernel image format',
                       False, efit)
@@ -364,41 +364,41 @@
 
             msg = 'Signature checking prevents use of unit addresses (@) in nodes'
             utils.run_and_log_expect_exception(
-                cons, [fit_check_sign, '-f', efit, '-k', dtb],
+                ubman, [fit_check_sign, '-f', efit, '-k', dtb],
                 1, msg)
             run_bootm(sha_algo, 'evil kernel@', msg, False, efit)
 
         # Create a new properly signed fit and replace header bytes
-        make_fit('sign-configs-%s%s.its' % (sha_algo, padding), cons, mkimage, dtc_args, datadir, fit)
+        make_fit('sign-configs-%s%s.its' % (sha_algo, padding), ubman, mkimage, dtc_args, datadir, fit)
         sign_fit(sha_algo, sign_options)
         bcfg = ubman.config.buildconfig
         max_size = int(bcfg.get('config_fit_signature_max_size', 0x10000000), 0)
         existing_size = replace_fit_totalsize(max_size + 1)
         run_bootm(sha_algo, 'Signed config with bad hash', 'Bad Data Hash',
                   False)
-        cons.log.action('%s: Check overflowed FIT header totalsize' % sha_algo)
+        ubman.log.action('%s: Check overflowed FIT header totalsize' % sha_algo)
 
         # Replace with existing header bytes
         replace_fit_totalsize(existing_size)
         run_bootm(sha_algo, 'signed config', 'dev+', True)
-        cons.log.action('%s: Check default FIT header totalsize' % sha_algo)
+        ubman.log.action('%s: Check default FIT header totalsize' % sha_algo)
 
         # Increment the first byte of the signature, which should cause failure
-        sig = utils.run_and_log(cons, 'fdtget -t bx %s %s value' %
+        sig = utils.run_and_log(ubman, 'fdtget -t bx %s %s value' %
                                 (fit, sig_node))
         byte_list = sig.split()
         byte = int(byte_list[0], 16)
         byte_list[0] = '%x' % (byte + 1)
         sig = ' '.join(byte_list)
-        utils.run_and_log(cons, 'fdtput -t bx %s %s value %s' %
+        utils.run_and_log(ubman, 'fdtput -t bx %s %s value %s' %
                           (fit, sig_node, sig))
 
         run_bootm(sha_algo, 'Signed config with bad hash', 'Bad Data Hash',
                   False)
 
-        cons.log.action('%s: Check bad config on the host' % sha_algo)
+        ubman.log.action('%s: Check bad config on the host' % sha_algo)
         utils.run_and_log_expect_exception(
-            cons, [fit_check_sign, '-f', fit, '-k', dtb],
+            ubman, [fit_check_sign, '-f', fit, '-k', dtb],
             1, 'Failed to verify required signature')
 
     def test_required_key(sha_algo, padding, sign_options):
@@ -416,19 +416,19 @@
         # Compile our device tree files for kernel and U-Boot. These are
         # regenerated here since mkimage will modify them (by adding a
         # public key) below.
-        dtc('sandbox-kernel.dts', cons, dtc_args, datadir, tmpdir, dtb)
-        dtc('sandbox-u-boot.dts', cons, dtc_args, datadir, tmpdir, dtb)
+        dtc('sandbox-kernel.dts', ubman, dtc_args, datadir, tmpdir, dtb)
+        dtc('sandbox-u-boot.dts', ubman, dtc_args, datadir, tmpdir, dtb)
 
-        cons.log.action('%s: Test FIT with configs images' % sha_algo)
+        ubman.log.action('%s: Test FIT with configs images' % sha_algo)
 
         # Build the FIT with prod key (keys required) and sign it. This puts the
         # signature into sandbox-u-boot.dtb, marked 'required'
-        make_fit('sign-configs-%s%s-prod.its' % (sha_algo, padding), cons, mkimage, dtc_args, datadir, fit)
+        make_fit('sign-configs-%s%s-prod.its' % (sha_algo, padding), ubman, mkimage, dtc_args, datadir, fit)
         sign_fit(sha_algo, sign_options)
 
         # Build the FIT with dev key (keys NOT required). This adds the
         # signature into sandbox-u-boot.dtb, NOT marked 'required'.
-        make_fit('sign-configs-%s%s.its' % (sha_algo, padding), cons, mkimage, dtc_args, datadir, fit)
+        make_fit('sign-configs-%s%s.its' % (sha_algo, padding), ubman, mkimage, dtc_args, datadir, fit)
         sign_fit_norequire(sha_algo, sign_options)
 
         # So now sandbox-u-boot.dtb two signatures, for the prod and dev keys.
@@ -440,7 +440,7 @@
 
         # Build the FIT with dev key (keys required) and sign it. This puts the
         # signature into sandbox-u-boot.dtb, marked 'required'.
-        make_fit('sign-configs-%s%s.its' % (sha_algo, padding), cons, mkimage, dtc_args, datadir, fit)
+        make_fit('sign-configs-%s%s.its' % (sha_algo, padding), ubman, mkimage, dtc_args, datadir, fit)
         sign_fit(sha_algo, sign_options)
 
         # Set the required-mode policy to "any".
@@ -449,7 +449,7 @@
         # a dev signature only (sign_fit() overwrites the FIT).
         # Try to boot the FIT with dev key. This FIT should be accepted by
         # U-Boot because the dev key is required and policy is "any" required key.
-        utils.run_and_log(cons, 'fdtput -t s %s /signature required-mode any' %
+        utils.run_and_log(ubman, 'fdtput -t s %s /signature required-mode any' %
                           dtb)
         run_bootm(sha_algo, 'multi required key', 'dev+', True)
 
@@ -459,7 +459,7 @@
         # a dev signature only (sign_fit() overwrites the FIT).
         # Try to boot the FIT with dev key. This FIT should not be accepted by
         # U-Boot because the prod key is required and policy is "all" required key
-        utils.run_and_log(cons, 'fdtput -t s %s /signature required-mode all' %
+        utils.run_and_log(ubman, 'fdtput -t s %s /signature required-mode all' %
                           dtb)
         run_bootm(sha_algo, 'multi required key', '', False)
 
@@ -473,22 +473,22 @@
         """
 
         dtb = '%ssandbox-u-boot-global%s.dtb' % (tmpdir, padding)
-        cons.config.dtb = dtb
+        ubman.config.dtb = dtb
 
         # Compile our device tree files for kernel and U-Boot. These are
         # regenerated here since mkimage will modify them (by adding a
         # public key) below.
-        dtc('sandbox-kernel.dts', cons, dtc_args, datadir, tmpdir, dtb)
+        dtc('sandbox-kernel.dts', ubman, dtc_args, datadir, tmpdir, dtb)
         dtc_options('sandbox-u-boot-global%s.dts' % padding, '-p 1024')
 
         # Build the FIT with dev key (keys NOT required). This adds the
         # signature into sandbox-u-boot.dtb, NOT marked 'required'.
-        make_fit('simple-images.its', cons, mkimage, dtc_args, datadir, fit)
+        make_fit('simple-images.its', ubman, mkimage, dtc_args, datadir, fit)
         sign_fit_dtb(sha_algo, '', dtb)
 
         # Build the dtb for binman that define the pre-load header
         # with the global sigature.
-        dtc('sandbox-binman%s.dts' % padding, cons, dtc_args, datadir, tmpdir, dtb)
+        dtc('sandbox-binman%s.dts' % padding, ubman, dtc_args, datadir, tmpdir, dtb)
 
         # Run binman to create the final image with the not signed fit
         # and the pre-load header that contains the global signature.
@@ -508,15 +508,14 @@
         # Check that the boot fails if the global signature is not provided
         run_bootm(sha_algo, 'global image signature', 'signature is mandatory', False)
 
-    cons = ubman
-    tmpdir = os.path.join(cons.config.result_dir, name) + '/'
+    tmpdir = os.path.join(ubman.config.result_dir, name) + '/'
     if not os.path.exists(tmpdir):
         os.mkdir(tmpdir)
-    datadir = cons.config.source_dir + '/test/py/tests/vboot/'
+    datadir = ubman.config.source_dir + '/test/py/tests/vboot/'
     fit = '%stest.fit' % tmpdir
-    mkimage = cons.config.build_dir + '/tools/mkimage'
-    binman = cons.config.source_dir + '/tools/binman/binman'
-    fit_check_sign = cons.config.build_dir + '/tools/fit_check_sign'
+    mkimage = ubman.config.build_dir + '/tools/mkimage'
+    binman = ubman.config.source_dir + '/tools/binman/binman'
+    fit_check_sign = ubman.config.build_dir + '/tools/fit_check_sign'
     dtc_args = '-I dts -O dtb -i %s' % tmpdir
     dtb = '%ssandbox-u-boot.dtb' % tmpdir
     sig_node = '/configurations/conf-1/signature'
@@ -535,9 +534,9 @@
 
     # We need to use our own device tree file. Remember to restore it
     # afterwards.
-    old_dtb = cons.config.dtb
+    old_dtb = ubman.config.dtb
     try:
-        cons.config.dtb = dtb
+        ubman.config.dtb = dtb
         if global_sign:
             test_global_sign(sha_algo, padding, sign_options)
         elif required:
@@ -546,8 +545,8 @@
             test_with_algo(sha_algo, padding, sign_options)
     finally:
         # Go back to the original U-Boot with the correct dtb.
-        cons.config.dtb = old_dtb
-        cons.restart_uboot()
+        ubman.config.dtb = old_dtb
+        ubman.restart_uboot()
 
 
 TESTDATA_IN = [
@@ -593,8 +592,8 @@
         args = [mkimage, '-F', '-k', tmpdir, fit]
         if options:
             args += options.split(' ')
-        cons.log.action('%s: Sign images' % sha_algo)
-        utils.run_and_log(cons, args)
+        ubman.log.action('%s: Sign images' % sha_algo)
+        utils.run_and_log(ubman, args)
 
     def test_add_pubkey(sha_algo, padding, sign_options):
         """Test fdt_add_pubkey utility with given hash algorithm and padding.
@@ -609,34 +608,33 @@
         """
 
         # Create a fresh .dtb without the public keys
-        dtc('sandbox-u-boot.dts', cons, dtc_args, datadir, tmpdir, dtb)
+        dtc('sandbox-u-boot.dts', ubman, dtc_args, datadir, tmpdir, dtb)
 
-        cons.log.action('%s: Test fdt_add_pubkey with signed configuration' % sha_algo)
+        ubman.log.action('%s: Test fdt_add_pubkey with signed configuration' % sha_algo)
         # Then add the dev key via the fdt_add_pubkey tool
-        utils.run_and_log(cons,
+        utils.run_and_log(ubman,
                           [fdt_add_pubkey, '-a', '%s,%s' %
                            ('sha256' if algo_arg else sha_algo,
                             'rsa3072' if sha_algo == 'sha384' else 'rsa2048'),
                            '-k', tmpdir, '-n', 'dev', '-r', 'conf', dtb])
 
-        make_fit('sign-configs-%s%s.its' % (sha_algo, padding), cons, mkimage, dtc_args, datadir, fit)
+        make_fit('sign-configs-%s%s.its' % (sha_algo, padding), ubman, mkimage, dtc_args, datadir, fit)
 
         # Sign images with our dev keys
         sign_fit(sha_algo, sign_options)
 
         # Check with fit_check_sign that FIT is signed with key
-        utils.run_and_log(cons, [fit_check_sign, '-f', fit, '-k', dtb])
+        utils.run_and_log(ubman, [fit_check_sign, '-f', fit, '-k', dtb])
 
-    cons = ubman
-    tmpdir = os.path.join(cons.config.result_dir, name) + '/'
+    tmpdir = os.path.join(ubman.config.result_dir, name) + '/'
     if not os.path.exists(tmpdir):
         os.mkdir(tmpdir)
-    datadir = cons.config.source_dir + '/test/py/tests/vboot/'
+    datadir = ubman.config.source_dir + '/test/py/tests/vboot/'
     fit = '%stest.fit' % tmpdir
-    mkimage = cons.config.build_dir + '/tools/mkimage'
-    binman = cons.config.source_dir + '/tools/binman/binman'
-    fit_check_sign = cons.config.build_dir + '/tools/fit_check_sign'
-    fdt_add_pubkey = cons.config.build_dir + '/tools/fdt_add_pubkey'
+    mkimage = ubman.config.build_dir + '/tools/mkimage'
+    binman = ubman.config.source_dir + '/tools/binman/binman'
+    fit_check_sign = ubman.config.build_dir + '/tools/fit_check_sign'
+    fdt_add_pubkey = ubman.config.build_dir + '/tools/fdt_add_pubkey'
     dtc_args = '-I dts -O dtb -i %s' % tmpdir
     dtb = '%ssandbox-u-boot.dtb' % tmpdir
 
diff --git a/test/py/tests/test_vpl.py b/test/py/tests/test_vpl.py
index 735e2c3..a269c7c 100644
--- a/test/py/tests/test_vpl.py
+++ b/test/py/tests/test_vpl.py
@@ -23,9 +23,8 @@
         ut_subtest (str): VPL test to be executed (e.g. 'dm platdata_phandle')
     """
     try:
-        cons = ubman
-        cons.restart_uboot_with_flags(['-u', '-k', ut_vpl_subtest.split()[1]])
-        output = cons.get_spawn_output().replace('\r', '')
+        ubman.restart_uboot_with_flags(['-u', '-k', ut_vpl_subtest.split()[1]])
+        output = ubman.get_spawn_output().replace('\r', '')
         assert 'failures: 0' in output
     finally:
         # Restart afterward in case a non-VPL test is run next. This should not