Replace assertErrorRegex by standard assertRaisesRegex

Author: Flamefire

easybuild/base/testing.py

@@ -66,7 +66,7 @@ def nicediff(txta, txtb, offset=5):
 
 
 class TestCase(OrigTestCase):
-    """Enhanced test case, provides extra functionality (e.g. an assertErrorRegex method)."""
+    """Enhanced test case, provides extra functionality."""
 
     longMessage = True  # print both standard messgae and custom message
 

test/framework/build_log.py

@@ -63,18 +63,18 @@ def test_easybuilderror(self):
         setLogFormat("%(name)s :: %(message)s")
 
         with self.log_to_testlogfile() as logfile:
-            self.assertErrorRegex(EasyBuildError, 'BOOM', raise_easybuilderror, 'BOOM')
+            self.assertRaisesRegex(EasyBuildError, 'BOOM', raise_easybuilderror, 'BOOM')
             logtxt = read_file(logfile)
 
         log_re = re.compile(r"^fancyroot ::.* BOOM \(at .*:[0-9]+ in [a-z_]+\)$", re.M)
         self.assertTrue(log_re.match(logtxt), "%s matches %s" % (log_re.pattern, logtxt))
 
         # test formatting of message
-        self.assertErrorRegex(EasyBuildError, 'BOOMBAF', raise_easybuilderror, 'BOOM%s', 'BAF')
+        self.assertRaisesRegex(EasyBuildError, 'BOOMBAF', raise_easybuilderror, 'BOOM%s', 'BAF')
 
         # a '%s' in a value used to template the error message should not print a traceback!
         with self.mocked_stdout_stderr():
-            self.assertErrorRegex(EasyBuildError, 'err: msg: %s', raise_easybuilderror, "err: %s", "msg: %s")
+            self.assertRaisesRegex(EasyBuildError, 'err: msg: %s', raise_easybuilderror, "err: %s", "msg: %s")
             stderr = self.get_stderr()
             stdout = self.get_stdout()
         # stdout/stderr should be *empty* (there should definitely not be a traceback)
@@ -83,15 +83,15 @@ def test_easybuilderror(self):
 
         # Need to all call a method in the "easybuild" package as everything else will be filtered out
         with self.log_to_testlogfile() as logfile:
-            self.assertErrorRegex(EasyBuildError, 'Failed to read', tweak_one, '/does/not/exist', '/tmp/new', {})
+            self.assertRaisesRegex(EasyBuildError, 'Failed to read', tweak_one, '/does/not/exist', '/tmp/new', {})
             logtxt: str = read_file(logfile)
 
         self.assertRegex(logtxt, '\n'.join(
             (r"EasyBuild encountered an error: Failed to read /does/not/exist:.*",
              r"Callstack:",
              r'\s+easybuild/tools/filetools\.py:\d+ in read_file',
              r'\s+easybuild/framework/easyconfig/tweak\.py:\d+ in tweak_one',
-             r'\s+easybuild/base/testing\.py:\d+ in assertErrorRegex',
+             r'\s+easybuild/base/testing\.py:\d+ in assertRaisesRegex',
              )), re.M)
 
     def test_easybuildlog(self):
@@ -156,10 +156,10 @@ def test_easybuildlog(self):
         logtxt_regex = re.compile(r'^%s' % expected_logtxt, re.M)
         self.assertTrue(logtxt_regex.search(logtxt), "Pattern '%s' found in %s" % (logtxt_regex.pattern, logtxt))
 
-        self.assertErrorRegex(EasyBuildError, r"DEPRECATED \(since .*: kaput", log.deprecated, "kaput", older_ver)
-        self.assertErrorRegex(EasyBuildError, r"DEPRECATED \(since .*: 2>1", log.deprecated, "2>1", '2.0', '1.0')
-        self.assertErrorRegex(EasyBuildError, r"DEPRECATED \(since .*: 2>1", log.deprecated, "2>1", '2.0',
-                              max_ver='1.0')
+        self.assertRaisesRegex(EasyBuildError, r"DEPRECATED \(since .*: kaput", log.deprecated, "kaput", older_ver)
+        self.assertRaisesRegex(EasyBuildError, r"DEPRECATED \(since .*: 2>1", log.deprecated, "2>1", '2.0', '1.0')
+        self.assertRaisesRegex(EasyBuildError, r"DEPRECATED \(since .*: 2>1", log.deprecated, "2>1", '2.0',
+                               max_ver='1.0')
 
         # wipe log so we can reuse it
         write_file(tmplog, '')
@@ -265,7 +265,7 @@ def run_check(args, silent=False, expected_stderr='', **kwargs):
         run_check(['You have been %s.', 'warned'], silent=True)
         run_check(['You %s %s %s.', 'have', 'been', 'warned'], silent=True)
 
-        self.assertErrorRegex(EasyBuildError, "Unknown named arguments", print_warning, 'foo', unknown_arg='bar')
+        self.assertRaisesRegex(EasyBuildError, "Unknown named arguments", print_warning, 'foo', unknown_arg='bar')
 
         # test passing of logger to print_warning
         tmp_logfile = os.path.join(self.test_prefix, 'test.log')
@@ -281,7 +281,7 @@ def run_check(args, silent=False, expected_stderr=''):
             """Helper function to check stdout/stderr produced via print_error."""
             self.mock_stderr(True)
             self.mock_stdout(True)
-            self.assertErrorRegex(SystemExit, '1', print_error, *args, silent=silent)
+            self.assertRaisesRegex(SystemExit, '1', print_error, *args, silent=silent)
             stderr = self.get_stderr()
             stdout = self.get_stdout()
             self.mock_stdout(False)
@@ -296,7 +296,7 @@ def run_check(args, silent=False, expected_stderr=''):
         run_check(['You have %s.', 'failed'], silent=True)
         run_check(['%s %s %s.', 'You', 'have', 'failed'], silent=True)
 
-        self.assertErrorRegex(EasyBuildError, "Unknown named arguments", print_error, 'foo', unknown_arg='bar')
+        self.assertRaisesRegex(EasyBuildError, "Unknown named arguments", print_error, 'foo', unknown_arg='bar')
 
     def test_print_msg(self):
         """Test print_msg"""
@@ -329,7 +329,7 @@ def run_check(msg, args, expected_stdout='', expected_stderr='', **kwargs):
         run_check("testing, 1, 2, 3", [], silent=True, stderr=True)
         run_check("testing, %s, %s, 3", ['1', '2'], silent=True, stderr=True)
 
-        self.assertErrorRegex(EasyBuildError, "Unknown named arguments", print_msg, 'foo', unknown_arg='bar')
+        self.assertRaisesRegex(EasyBuildError, "Unknown named arguments", print_msg, 'foo', unknown_arg='bar')
 
     def test_time_str_since(self):
         """Test time_str_since"""
@@ -364,7 +364,7 @@ def run_check(msg, args, expected_stdout='', **kwargs):
         run_check("test 123", [], silent=True)
         run_check("test %s", ['123'], silent=True)
 
-        self.assertErrorRegex(EasyBuildError, "Unknown named arguments", dry_run_msg, 'foo', unknown_arg='bar')
+        self.assertRaisesRegex(EasyBuildError, "Unknown named arguments", dry_run_msg, 'foo', unknown_arg='bar')
 
     def test_dry_run_warning(self):
         """Test dry_run_warningmsg"""
@@ -385,7 +385,7 @@ def run_check(msg, args, expected_stdout='', **kwargs):
         run_check("test 123", [], silent=True)
         run_check("test %s", ['123'], silent=True)
 
-        self.assertErrorRegex(EasyBuildError, "Unknown named arguments", dry_run_warning, 'foo', unknown_arg='bar')
+        self.assertRaisesRegex(EasyBuildError, "Unknown named arguments", dry_run_warning, 'foo', unknown_arg='bar')
 
     def test_init_logging(self):
         """Test init_logging function."""
@@ -442,8 +442,8 @@ def test_init_logging(self):
         stop_logging(logfile, logtostdout=True)
 
     def test_raise_nosupport(self):
-        self.assertErrorRegex(EasyBuildError, 'NO LONGER SUPPORTED since v42: foobar;',
-                              raise_nosupport, 'foobar', 42)
+        self.assertRaisesRegex(EasyBuildError, 'NO LONGER SUPPORTED since v42: foobar;',
+                               raise_nosupport, 'foobar', 42)
 
 
 def suite(loader=None):

test/framework/config.py

@@ -169,7 +169,7 @@ def test_generaloption_config(self):
         installpath_software = tempfile.mkdtemp(prefix='installpath-software')
         os.environ['EASYBUILD_SUBDIR_SOFTWARE'] = installpath_software
         error_regex = r"Found problems validating the options.*'subdir_software' must specify a \*relative\* path"
-        self.assertErrorRegex(EasyBuildError, error_regex, init_config)
+        self.assertRaisesRegex(EasyBuildError, error_regex, init_config)
 
         del os.environ['EASYBUILD_PREFIX']
         del os.environ['EASYBUILD_SUBDIR_SOFTWARE']
@@ -185,7 +185,7 @@ def test_error_env_var_typo(self):
         error = r"Found 2 environment variable\(s\) that are prefixed with %s " % CONFIG_ENV_VAR_PREFIX
         error += r"but do not match valid option\(s\): "
         error += r','.join(['EASYBUILD_FOO', 'EASYBUILD_THERESNOSUCHCONFIGURATIONOPTION'])
-        self.assertErrorRegex(EasyBuildError, error, init_config)
+        self.assertRaisesRegex(EasyBuildError, error, init_config)
 
         del os.environ['EASYBUILD_THERESNOSUCHCONFIGURATIONOPTION']
         del os.environ['EASYBUILD_FOO']
@@ -198,7 +198,7 @@ def test_install_path(self):
         self.assertEqual(install_path(typ='mod'), os.path.join(self.test_installpath, 'modules'))
         self.assertEqual(install_path('modules'), os.path.join(self.test_installpath, 'modules'))
 
-        self.assertErrorRegex(EasyBuildError, "Unknown type specified", install_path, typ='foo')
+        self.assertRaisesRegex(EasyBuildError, "Unknown type specified", install_path, typ='foo')
 
         args = [
             '--subdir-software', 'SOFT',
@@ -358,16 +358,16 @@ def test_build_options(self):
         self.assertTrue(bo['force'])
 
         # updating is impossible (methods are not even available)
-        self.assertErrorRegex(Exception, '.*(item assignment|no attribute).*', lambda x: bo.update(x), {'debug': True})
-        self.assertErrorRegex(AttributeError, '.*no attribute.*', lambda x: bo.__setitem__(*x), ('debug', True))
+        self.assertRaisesRegex(Exception, '.*(item assignment|no attribute).*', lambda x: bo.update(x), {'debug': True})
+        self.assertRaisesRegex(AttributeError, '.*no attribute.*', lambda x: bo.__setitem__(*x), ('debug', True))
 
         # only valid keys can be set
         BuildOptions.__class__._instances.clear()
         msg = r"Encountered unknown keys .* \(known keys: .*"
-        self.assertErrorRegex(KeyError, msg, BuildOptions, {'thisisclearlynotavalidbuildoption': 'FAIL'})
+        self.assertRaisesRegex(KeyError, msg, BuildOptions, {'thisisclearlynotavalidbuildoption': 'FAIL'})
 
         # test init_build_options and build_option functions
-        self.assertErrorRegex(KeyError, msg, init_build_options, {'thisisclearlynotavalidbuildoption': 'FAIL'})
+        self.assertRaisesRegex(KeyError, msg, init_build_options, {'thisisclearlynotavalidbuildoption': 'FAIL'})
         bo = init_build_options({
             'robot_path': '/some/robot/path',
             'stop': 'configure',
@@ -649,7 +649,7 @@ def test_log_file_format(self):
         # test handling of incorrect setting for --logfile-format
         init_config(args=['--logfile-format=easybuild,log.txt,thisiswrong'])
         error_pattern = "Incorrect log file format specification, should be 2-tuple"
-        self.assertErrorRegex(EasyBuildError, error_pattern, log_file_format)
+        self.assertRaisesRegex(EasyBuildError, error_pattern, log_file_format)
 
     def test_log_path(self):
         """Test for log_path()."""

test/framework/containers.py

@@ -110,16 +110,16 @@ def test_end2end_singularity_recipe_config(self):
 
         args.extend(['--container-config', 'osversion=7.6.1810'])
         error_pattern = r"Keyword 'bootstrap' is required in container base config"
-        self.assertErrorRegex(EasyBuildError, error_pattern, self.run_main, args, raise_error=True)
+        self.assertRaisesRegex(EasyBuildError, error_pattern, self.run_main, args, raise_error=True)
 
         args.extend(['--container-config', 'bootstrap=foobar'])
         error_pattern = r"Unknown value specified for 'bootstrap' keyword: foobar \(known: arch, busybox, debootstrap, "
-        self.assertErrorRegex(EasyBuildError, error_pattern, self.run_main, args, raise_error=True)
+        self.assertRaisesRegex(EasyBuildError, error_pattern, self.run_main, args, raise_error=True)
 
         # default mirror URL for yum bootstrap agent uses ${OSVERSION}, so 'osversion' must be specified too
         args.extend(['--container-config', 'bootstrap=yum'])
         error_pattern = "Keyword 'osversion' is required in container base config when '%{OSVERSION}' is used"
-        self.assertErrorRegex(EasyBuildError, error_pattern, self.run_main, args, raise_error=True)
+        self.assertRaisesRegex(EasyBuildError, error_pattern, self.run_main, args, raise_error=True)
 
         args[-1] = 'bootstrap=yum,osversion=7.6.1810'
         stdout, stderr = self.run_main(args, raise_error=True)
@@ -197,7 +197,7 @@ def test_end2end_singularity_recipe_config(self):
         error_pattern = "Keyword 'from' is required in container base config when using bootstrap agent"
         for (bootstrap, from_spec) in test_cases:
             args[-1] = 'bootstrap=%s' % bootstrap
-            self.assertErrorRegex(EasyBuildError, error_pattern, self.run_main, args, raise_error=True)
+            self.assertRaisesRegex(EasyBuildError, error_pattern, self.run_main, args, raise_error=True)
 
             args[-1] += ',from=%s' % from_spec
             remove_file(test_container_recipe)
@@ -281,7 +281,7 @@ def test_end2end_singularity_image(self):
 
         if which('singularity') is None:
             error_pattern = "singularity with version 2.4 or higher not found on your system."
-            self.assertErrorRegex(EasyBuildError, error_pattern, self.eb_main, args, raise_error=True)
+            self.assertRaisesRegex(EasyBuildError, error_pattern, self.eb_main, args, raise_error=True)
 
         # install mocked versions of 'sudo' and 'singularity' commands
         singularity = os.path.join(self.test_prefix, 'bin', 'singularity')
@@ -338,7 +338,7 @@ def test_end2end_singularity_image(self):
 
         error_pattern = "Container image already exists at %s, not overwriting it without --force" % cont_img
         self.mock_stdout(True)
-        self.assertErrorRegex(EasyBuildError, error_pattern, self.run_main, args, raise_error=True)
+        self.assertRaisesRegex(EasyBuildError, error_pattern, self.run_main, args, raise_error=True)
         self.mock_stdout(False)
 
         args.append('--force')
@@ -380,11 +380,11 @@ def test_end2end_dockerfile(self):
         ]
 
         error_pattern = "Unsupported container config 'not-supported'"
-        self.assertErrorRegex(EasyBuildError,
-                              error_pattern,
-                              self.run_main,
-                              base_args + ['--container-config=not-supported'],
-                              raise_error=True)
+        self.assertRaisesRegex(EasyBuildError,
+                               error_pattern,
+                               self.run_main,
+                               base_args + ['--container-config=not-supported'],
+                               raise_error=True)
 
         for cont_base in ['ubuntu:20.04', 'centos:7']:
             stdout, stderr = self.run_main(base_args + ['--container-config=%s' % cont_base])
@@ -397,11 +397,11 @@ def test_end2end_dockerfile(self):
 
         error_pattern = "Container recipe at %s/containers/Dockerfile.toy-0.0 already exists, " \
                         "not overwriting it without --force" % self.test_prefix
-        self.assertErrorRegex(EasyBuildError,
-                              error_pattern,
-                              self.run_main,
-                              base_args + ['--container-config=centos:7'],
-                              raise_error=True)
+        self.assertRaisesRegex(EasyBuildError,
+                               error_pattern,
+                               self.run_main,
+                               base_args + ['--container-config=centos:7'],
+                               raise_error=True)
 
         remove_file(os.path.join(self.test_prefix, 'containers', 'Dockerfile.toy-0.0'))
 
@@ -441,7 +441,7 @@ def test_end2end_docker_image(self):
 
         if not which('docker'):
             error_pattern = "docker not found on your system."
-            self.assertErrorRegex(EasyBuildError, error_pattern, self.run_main, args, raise_error=True)
+            self.assertRaisesRegex(EasyBuildError, error_pattern, self.run_main, args, raise_error=True)
 
         # install mocked versions of 'sudo' and 'docker' commands
         docker = os.path.join(self.test_prefix, 'bin', 'docker')
@@ -488,7 +488,7 @@ def test_container_config_template_recipe(self):
             'toy-0.0.eb',
         ]
         error_pattern = "--container-config must be specified!"
-        self.assertErrorRegex(EasyBuildError, error_pattern, self.run_main, args)
+        self.assertRaisesRegex(EasyBuildError, error_pattern, self.run_main, args)
 
         args.extend(['--container-config', 'bootstrap=localimage,from=foobar'])
         stdout, stderr = self.run_main(args)

test/framework/docs.py

@@ -1288,8 +1288,8 @@ def test_mk_table(self):
         res = mk_rst_table(titles, table)
         self.assertEqual(res, expected_rst)
 
-        self.assertErrorRegex(ValueError, "Number of titles/columns should be equal", mk_md_table, titles, [])
-        self.assertErrorRegex(ValueError, "Number of titles/columns should be equal", mk_rst_table, titles, [])
+        self.assertRaisesRegex(ValueError, "Number of titles/columns should be equal", mk_md_table, titles, [])
+        self.assertRaisesRegex(ValueError, "Number of titles/columns should be equal", mk_rst_table, titles, [])
 
     def test_title_and_table(self):
         """
@@ -1329,8 +1329,8 @@ def test_title_and_table(self):
         self.assertEqual(res, expected_rst)
 
         error_pattern = "Number of titles/columns should be equal"
-        self.assertErrorRegex(ValueError, error_pattern, md_title_and_table, '', titles, [])
-        self.assertErrorRegex(ValueError, error_pattern, rst_title_and_table, '', titles, [('val 11', 'val 12')])
+        self.assertRaisesRegex(ValueError, error_pattern, md_title_and_table, '', titles, [])
+        self.assertRaisesRegex(ValueError, error_pattern, rst_title_and_table, '', titles, [('val 11', 'val 12')])
 
     def test_help(self):
         """