From 97104f1221b64ef36cf42cb90c5a0eff263a2adb Mon Sep 17 00:00:00 2001 From: Matt Clay Date: Fri, 7 Jan 2022 12:31:11 -0800 Subject: [PATCH] Avoid deprecated TestCase functions in unit tests. (#76678) * Avoid deprecated TestCase functions in unit tests. * Add assertRaisesRegex for Python 2.7. * Fix indentation. --- test/units/cli/test_vault.py | 12 +- test/units/compat/unittest.py | 4 + .../module_utils/facts/test_collector.py | 30 ++-- test/units/parsing/test_dataloader.py | 8 +- test/units/parsing/vault/test_vault.py | 132 +++++++++--------- test/units/parsing/vault/test_vault_editor.py | 62 ++++---- test/units/parsing/yaml/test_loader.py | 4 +- test/units/parsing/yaml/test_objects.py | 2 +- test/units/playbook/test_base.py | 14 +- test/units/playbook/test_conditional.py | 40 +++--- test/units/playbook/test_helpers.py | 76 +++++----- test/units/plugins/action/test_action.py | 2 +- test/units/plugins/cache/test_cache.py | 6 +- test/units/plugins/callback/test_callback.py | 4 +- test/units/template/test_templar.py | 58 ++++---- 15 files changed, 229 insertions(+), 225 deletions(-) diff --git a/test/units/cli/test_vault.py b/test/units/cli/test_vault.py index e705dfe81bb..58a37e3496d 100644 --- a/test/units/cli/test_vault.py +++ b/test/units/cli/test_vault.py @@ -70,18 +70,18 @@ class TestVaultCli(unittest.TestCase): mock_setup_vault_secrets.return_value = [] cli = VaultCLI(args=['ansible-vault', 'view', '/dev/null/foo']) cli.parse() - self.assertRaisesRegexp(errors.AnsibleOptionsError, - "A vault password is required to use Ansible's Vault", - cli.run) + self.assertRaisesRegex(errors.AnsibleOptionsError, + "A vault password is required to use Ansible's Vault", + cli.run) @patch('ansible.cli.vault.VaultCLI.setup_vault_secrets') def test_encrypt_missing_file_no_secret(self, mock_setup_vault_secrets): mock_setup_vault_secrets.return_value = [] cli = VaultCLI(args=['ansible-vault', 'encrypt', '/dev/null/foo']) cli.parse() - self.assertRaisesRegexp(errors.AnsibleOptionsError, - "A vault password is required to use Ansible's Vault", - cli.run) + self.assertRaisesRegex(errors.AnsibleOptionsError, + "A vault password is required to use Ansible's Vault", + cli.run) @patch('ansible.cli.vault.VaultCLI.setup_vault_secrets') @patch('ansible.cli.vault.VaultEditor') diff --git a/test/units/compat/unittest.py b/test/units/compat/unittest.py index 98f08ad6a84..77bb4c054cf 100644 --- a/test/units/compat/unittest.py +++ b/test/units/compat/unittest.py @@ -36,3 +36,7 @@ if sys.version_info < (2, 7): print('You need unittest2 installed on python2.6.x to run tests') else: from unittest import * + + if not hasattr(TestCase, 'assertRaisesRegex'): + # added in Python 3.2 + TestCase.assertRaisesRegex = TestCase.assertRaisesRegexp diff --git a/test/units/module_utils/facts/test_collector.py b/test/units/module_utils/facts/test_collector.py index 9eab89f7aa5..4fc4bc5f72d 100644 --- a/test/units/module_utils/facts/test_collector.py +++ b/test/units/module_utils/facts/test_collector.py @@ -265,12 +265,12 @@ class TestGetCollectorNames(unittest.TestCase): valid_subsets = frozenset(['my_fact', 'something_else']) minimal_gather_subset = frozenset(['my_fact']) - self.assertRaisesRegexp(TypeError, - r'Bad subset .* given to Ansible.*allowed\:.*all,.*my_fact.*', - collector.get_collector_names, - valid_subsets=valid_subsets, - minimal_gather_subset=minimal_gather_subset, - gather_subset=['my_fact', 'not_a_valid_gather_subset']) + self.assertRaisesRegex(TypeError, + r'Bad subset .* given to Ansible.*allowed\:.*all,.*my_fact.*', + collector.get_collector_names, + valid_subsets=valid_subsets, + minimal_gather_subset=minimal_gather_subset, + gather_subset=['my_fact', 'not_a_valid_gather_subset']) class TestFindUnresolvedRequires(unittest.TestCase): @@ -349,10 +349,10 @@ class TestResolveRequires(unittest.TestCase): all_fact_subsets = {'env': [default_collectors.EnvFactCollector], 'network': [default_collectors.LinuxNetworkCollector], 'virtual': [default_collectors.LinuxVirtualCollector]} - self.assertRaisesRegexp(collector.UnresolvedFactDep, - 'unresolved fact dep.*required_thing2', - collector.resolve_requires, - unresolved, all_fact_subsets) + self.assertRaisesRegex(collector.UnresolvedFactDep, + 'unresolved fact dep.*required_thing2', + collector.resolve_requires, + unresolved, all_fact_subsets) def test(self): unresolved = ['env', 'network'] @@ -556,8 +556,8 @@ class TestCollectorClassesFromGatherSubset(unittest.TestCase): def test_unknown_collector(self): # something claims 'unknown_collector' is a valid gather_subset, but there is # no FactCollector mapped to 'unknown_collector' - self.assertRaisesRegexp(TypeError, - r'Bad subset.*unknown_collector.*given to Ansible.*allowed\:.*all,.*env.*', - self._classes, - all_collector_classes=default_collectors.collectors, - gather_subset=['env', 'unknown_collector']) + self.assertRaisesRegex(TypeError, + r'Bad subset.*unknown_collector.*given to Ansible.*allowed\:.*all,.*env.*', + self._classes, + all_collector_classes=default_collectors.collectors, + gather_subset=['env', 'unknown_collector']) diff --git a/test/units/parsing/test_dataloader.py b/test/units/parsing/test_dataloader.py index 3cc8d45196e..36b113c7715 100644 --- a/test/units/parsing/test_dataloader.py +++ b/test/units/parsing/test_dataloader.py @@ -138,8 +138,8 @@ class TestDataLoader(unittest.TestCase): self.assertTrue(self._loader.is_directory(os.path.dirname(__file__))) def test_get_file_contents_none_path(self): - self.assertRaisesRegexp(AnsibleParserError, 'Invalid filename', - self._loader._get_file_contents, None) + self.assertRaisesRegex(AnsibleParserError, 'Invalid filename', + self._loader._get_file_contents, None) def test_get_file_contents_non_existent_path(self): self.assertRaises(AnsibleFileNotFound, self._loader._get_file_contents, '/non_existent_file') @@ -169,7 +169,7 @@ class TestPathDwimRelativeStackDataLoader(unittest.TestCase): self._loader = DataLoader() def test_none(self): - self.assertRaisesRegexp(AnsibleFileNotFound, 'on the Ansible Controller', self._loader.path_dwim_relative_stack, None, None, None) + self.assertRaisesRegex(AnsibleFileNotFound, 'on the Ansible Controller', self._loader.path_dwim_relative_stack, None, None, None) def test_empty_strings(self): self.assertEqual(self._loader.path_dwim_relative_stack('', '', ''), './') @@ -218,7 +218,7 @@ class TestDataLoaderWithVault(unittest.TestCase): self.assertRaises(AnsibleVaultError, self._loader.get_real_file, self.test_vault_data_path) def test_get_real_file_not_a_path(self): - self.assertRaisesRegexp(AnsibleParserError, 'Invalid filename', self._loader.get_real_file, None) + self.assertRaisesRegex(AnsibleParserError, 'Invalid filename', self._loader.get_real_file, None) @patch.multiple(DataLoader, path_exists=lambda s, x: True, is_file=lambda s, x: True) def test_parse_from_vault_1_1_file(self): diff --git a/test/units/parsing/vault/test_vault.py b/test/units/parsing/vault/test_vault.py index 0a9e395bb7e..a4efb7c543e 100644 --- a/test/units/parsing/vault/test_vault.py +++ b/test/units/parsing/vault/test_vault.py @@ -51,18 +51,18 @@ class TestUnhexlify(unittest.TestCase): def test_odd_length(self): b_data = b'123456789abcdefghijklmnopqrstuvwxyz' - self.assertRaisesRegexp(vault.AnsibleVaultFormatError, - '.*Vault format unhexlify error.*', - vault._unhexlify, - b_data) + self.assertRaisesRegex(vault.AnsibleVaultFormatError, + '.*Vault format unhexlify error.*', + vault._unhexlify, + b_data) def test_nonhex(self): b_data = b'6z36316566653264333665333637623064303639353237620a636366633565663263336335656532' - self.assertRaisesRegexp(vault.AnsibleVaultFormatError, - '.*Vault format unhexlify error.*Non-hexadecimal digit found', - vault._unhexlify, - b_data) + self.assertRaisesRegex(vault.AnsibleVaultFormatError, + '.*Vault format unhexlify error.*Non-hexadecimal digit found', + vault._unhexlify, + b_data) class TestParseVaulttext(unittest.TestCase): @@ -91,10 +91,10 @@ class TestParseVaulttext(unittest.TestCase): b_vaulttext_envelope = to_bytes(vaulttext_envelope, errors='strict', encoding='utf-8') b_vaulttext, b_version, cipher_name, vault_id = vault.parse_vaulttext_envelope(b_vaulttext_envelope) - self.assertRaisesRegexp(vault.AnsibleVaultFormatError, - '.*Vault format unhexlify error.*Non-hexadecimal digit found', - vault.parse_vaulttext, - b_vaulttext_envelope) + self.assertRaisesRegex(vault.AnsibleVaultFormatError, + '.*Vault format unhexlify error.*Non-hexadecimal digit found', + vault.parse_vaulttext, + b_vaulttext_envelope) class TestVaultSecret(unittest.TestCase): @@ -133,18 +133,18 @@ class TestPromptVaultSecret(unittest.TestCase): @patch('ansible.parsing.vault.display.prompt', side_effect=EOFError) def test_prompt_eoferror(self, mock_display_prompt): secret = vault.PromptVaultSecret(vault_id='test_id') - self.assertRaisesRegexp(vault.AnsibleVaultError, - 'EOFError.*test_id', - secret.load) + self.assertRaisesRegex(vault.AnsibleVaultError, + 'EOFError.*test_id', + secret.load) @patch('ansible.parsing.vault.display.prompt', side_effect=['first_password', 'second_password']) def test_prompt_passwords_dont_match(self, mock_display_prompt): secret = vault.PromptVaultSecret(vault_id='test_id', prompt_formats=['Vault password: ', 'Confirm Vault password: ']) - self.assertRaisesRegexp(errors.AnsibleError, - 'Passwords do not match', - secret.load) + self.assertRaisesRegex(errors.AnsibleError, + 'Passwords do not match', + secret.load) class TestFileVaultSecret(unittest.TestCase): @@ -200,9 +200,9 @@ class TestFileVaultSecret(unittest.TestCase): fake_loader = DictDataLoader({tmp_file.name: ''}) secret = vault.FileVaultSecret(loader=fake_loader, filename=tmp_file.name) - self.assertRaisesRegexp(vault.AnsibleVaultPasswordError, - 'Invalid vault password was provided from file.*%s' % tmp_file.name, - secret.load) + self.assertRaisesRegex(vault.AnsibleVaultPasswordError, + 'Invalid vault password was provided from file.*%s' % tmp_file.name, + secret.load) os.unlink(tmp_file.name) @@ -241,9 +241,9 @@ class TestFileVaultSecret(unittest.TestCase): fake_loader = DictDataLoader({filename: 'sdfadf'}) secret = vault.FileVaultSecret(loader=fake_loader, filename=filename) - self.assertRaisesRegexp(errors.AnsibleError, - '.*Could not read vault password file.*/dev/null/foobar.*Not a directory', - secret.load) + self.assertRaisesRegex(errors.AnsibleError, + '.*Could not read vault password file.*/dev/null/foobar.*Not a directory', + secret.load) def test_file_not_found(self): tmp_file = tempfile.NamedTemporaryFile() @@ -253,9 +253,9 @@ class TestFileVaultSecret(unittest.TestCase): fake_loader = DictDataLoader({filename: 'sdfadf'}) secret = vault.FileVaultSecret(loader=fake_loader, filename=filename) - self.assertRaisesRegexp(errors.AnsibleError, - '.*Could not read vault password file.*%s.*' % filename, - secret.load) + self.assertRaisesRegex(errors.AnsibleError, + '.*Could not read vault password file.*%s.*' % filename, + secret.load) class TestScriptVaultSecret(unittest.TestCase): @@ -285,9 +285,9 @@ class TestScriptVaultSecret(unittest.TestCase): secret = vault.ScriptVaultSecret() with patch.object(secret, 'loader') as mock_loader: mock_loader.is_executable = MagicMock(return_value=True) - self.assertRaisesRegexp(vault.AnsibleVaultPasswordError, - 'Invalid vault password was provided from script', - secret.load) + self.assertRaisesRegex(vault.AnsibleVaultPasswordError, + 'Invalid vault password was provided from script', + secret.load) @patch('ansible.parsing.vault.subprocess.Popen') def test_read_file_os_error(self, mock_popen): @@ -296,9 +296,9 @@ class TestScriptVaultSecret(unittest.TestCase): secret = vault.ScriptVaultSecret() with patch.object(secret, 'loader') as mock_loader: mock_loader.is_executable = MagicMock(return_value=True) - self.assertRaisesRegexp(errors.AnsibleError, - 'Problem running vault password script.*', - secret.load) + self.assertRaisesRegex(errors.AnsibleError, + 'Problem running vault password script.*', + secret.load) @patch('ansible.parsing.vault.subprocess.Popen') def test_read_file_not_executable(self, mock_popen): @@ -306,9 +306,9 @@ class TestScriptVaultSecret(unittest.TestCase): secret = vault.ScriptVaultSecret() with patch.object(secret, 'loader') as mock_loader: mock_loader.is_executable = MagicMock(return_value=False) - self.assertRaisesRegexp(vault.AnsibleVaultError, - 'The vault password script .* was not executable', - secret.load) + self.assertRaisesRegex(vault.AnsibleVaultError, + 'The vault password script .* was not executable', + secret.load) @patch('ansible.parsing.vault.subprocess.Popen') def test_read_file_non_zero_return_code(self, mock_popen): @@ -319,9 +319,9 @@ class TestScriptVaultSecret(unittest.TestCase): secret = vault.ScriptVaultSecret(filename='/dev/null/some_vault_secret') with patch.object(secret, 'loader') as mock_loader: mock_loader.is_executable = MagicMock(return_value=True) - self.assertRaisesRegexp(errors.AnsibleError, - r'Vault password script.*returned non-zero \(%s\): %s' % (rc, stderr), - secret.load) + self.assertRaisesRegex(errors.AnsibleError, + r'Vault password script.*returned non-zero \(%s\): %s' % (rc, stderr), + secret.load) class TestScriptIsClient(unittest.TestCase): @@ -382,11 +382,11 @@ class TestGetFileVaultSecret(unittest.TestCase): filename = '/dev/null/foobar' fake_loader = DictDataLoader({filename: 'sdfadf'}) - self.assertRaisesRegexp(errors.AnsibleError, - '.*The vault password file %s was not found.*' % filename, - vault.get_file_vault_secret, - filename=filename, - loader=fake_loader) + self.assertRaisesRegex(errors.AnsibleError, + '.*The vault password file %s was not found.*' % filename, + vault.get_file_vault_secret, + filename=filename, + loader=fake_loader) def test_file_not_found(self): tmp_file = tempfile.NamedTemporaryFile() @@ -395,11 +395,11 @@ class TestGetFileVaultSecret(unittest.TestCase): fake_loader = DictDataLoader({filename: 'sdfadf'}) - self.assertRaisesRegexp(errors.AnsibleError, - '.*The vault password file %s was not found.*' % filename, - vault.get_file_vault_secret, - filename=filename, - loader=fake_loader) + self.assertRaisesRegex(errors.AnsibleError, + '.*The vault password file %s was not found.*' % filename, + vault.get_file_vault_secret, + filename=filename, + loader=fake_loader) class TestVaultIsEncrypted(unittest.TestCase): @@ -645,10 +645,10 @@ class TestVaultLib(unittest.TestCase): v = vault.VaultLib(vault_secrets) plaintext = u'Some text to encrypt in a café' - self.assertRaisesRegexp(vault.AnsibleVaultError, - '.*A vault password must be specified to encrypt data.*', - v.encrypt, - plaintext) + self.assertRaisesRegex(vault.AnsibleVaultError, + '.*A vault password must be specified to encrypt data.*', + v.encrypt, + plaintext) def test_format_vaulttext_envelope(self): cipher_name = "TEST" @@ -712,10 +712,10 @@ class TestVaultLib(unittest.TestCase): v_none = vault.VaultLib(None) # so set secrets None explicitly v_none.secrets = None - self.assertRaisesRegexp(vault.AnsibleVaultError, - '.*A vault password must be specified to decrypt data.*', - v_none.decrypt, - b_vaulttext) + self.assertRaisesRegex(vault.AnsibleVaultError, + '.*A vault password must be specified to decrypt data.*', + v_none.decrypt, + b_vaulttext) def test_encrypt_decrypt_aes256_empty_secrets(self): vault_secrets = self._vault_secrets_from_password('default', 'ansible') @@ -727,10 +727,10 @@ class TestVaultLib(unittest.TestCase): vault_secrets_empty = [] v_none = vault.VaultLib(vault_secrets_empty) - self.assertRaisesRegexp(vault.AnsibleVaultError, - '.*Attempting to decrypt but no vault secrets found.*', - v_none.decrypt, - b_vaulttext) + self.assertRaisesRegex(vault.AnsibleVaultError, + '.*Attempting to decrypt but no vault secrets found.*', + v_none.decrypt, + b_vaulttext) def test_encrypt_decrypt_aes256_multiple_secrets_all_wrong(self): plaintext = u'Some text to encrypt in a café' @@ -740,11 +740,11 @@ class TestVaultLib(unittest.TestCase): ('wrong-password', TextVaultSecret('wrong-password'))] v_multi = vault.VaultLib(vault_secrets) - self.assertRaisesRegexp(errors.AnsibleError, - '.*Decryption failed.*', - v_multi.decrypt, - b_vaulttext, - filename='/dev/null/fake/filename') + self.assertRaisesRegex(errors.AnsibleError, + '.*Decryption failed.*', + v_multi.decrypt, + b_vaulttext, + filename='/dev/null/fake/filename') def test_encrypt_decrypt_aes256_multiple_secrets_one_valid(self): plaintext = u'Some text to encrypt in a café' diff --git a/test/units/parsing/vault/test_vault_editor.py b/test/units/parsing/vault/test_vault_editor.py index 1483bb52f55..a47a45d8d29 100644 --- a/test/units/parsing/vault/test_vault_editor.py +++ b/test/units/parsing/vault/test_vault_editor.py @@ -142,11 +142,11 @@ class TestVaultEditor(unittest.TestCase): ve = self._vault_editor() - self.assertRaisesRegexp(errors.AnsibleError, - error_txt, - ve._edit_file_helper, - src_file_path, - self.vault_secret) + self.assertRaisesRegex(errors.AnsibleError, + error_txt, + ve._edit_file_helper, + src_file_path, + self.vault_secret) @patch('ansible.parsing.vault.subprocess.call') def test_edit_file_helper_symlink_target(self, mock_sp_call): @@ -249,11 +249,11 @@ class TestVaultEditor(unittest.TestCase): ve = self._vault_editor() ve.encrypt_file(src_file_path, self.vault_secret) - self.assertRaisesRegexp(errors.AnsibleError, - 'The value for the new_password to rekey', - ve.rekey_file, - src_file_path, - None) + self.assertRaisesRegex(errors.AnsibleError, + 'The value for the new_password to rekey', + ve.rekey_file, + src_file_path, + None) def test_rekey_file_not_encrypted(self): self._test_dir = self._create_test_dir() @@ -264,10 +264,10 @@ class TestVaultEditor(unittest.TestCase): ve = self._vault_editor() new_password = 'password2:electricbugaloo' - self.assertRaisesRegexp(errors.AnsibleError, - 'input is not vault encrypted data', - ve.rekey_file, - src_file_path, new_password) + self.assertRaisesRegex(errors.AnsibleError, + 'input is not vault encrypted data', + ve.rekey_file, + src_file_path, new_password) def test_plaintext(self): self._test_dir = self._create_test_dir() @@ -288,10 +288,10 @@ class TestVaultEditor(unittest.TestCase): src_file_path = self._create_file(self._test_dir, 'src_file', content=src_file_contents) ve = self._vault_editor() - self.assertRaisesRegexp(errors.AnsibleError, - 'input is not vault encrypted data', - ve.plaintext, - src_file_path) + self.assertRaisesRegex(errors.AnsibleError, + 'input is not vault encrypted data', + ve.plaintext, + src_file_path) def test_encrypt_file(self): self._test_dir = self._create_test_dir() @@ -426,10 +426,10 @@ class TestVaultEditor(unittest.TestCase): mock_sp_call.side_effect = faux_editor ve = self._vault_editor() - self.assertRaisesRegexp(errors.AnsibleError, - 'input is not vault encrypted data', - ve.edit_file, - src_file_path) + self.assertRaisesRegex(errors.AnsibleError, + 'input is not vault encrypted data', + ve.edit_file, + src_file_path) def test_create_file_exists(self): self._test_dir = self._create_test_dir() @@ -437,11 +437,11 @@ class TestVaultEditor(unittest.TestCase): src_file_path = self._create_file(self._test_dir, 'src_file', content=src_contents) ve = self._vault_editor() - self.assertRaisesRegexp(errors.AnsibleError, - 'please use .edit. instead', - ve.create_file, - src_file_path, - self.vault_secret) + self.assertRaisesRegex(errors.AnsibleError, + 'please use .edit. instead', + ve.create_file, + src_file_path, + self.vault_secret) def test_decrypt_file_exception(self): self._test_dir = self._create_test_dir() @@ -449,10 +449,10 @@ class TestVaultEditor(unittest.TestCase): src_file_path = self._create_file(self._test_dir, 'src_file', content=src_contents) ve = self._vault_editor() - self.assertRaisesRegexp(errors.AnsibleError, - 'input is not vault encrypted data', - ve.decrypt_file, - src_file_path) + self.assertRaisesRegex(errors.AnsibleError, + 'input is not vault encrypted data', + ve.decrypt_file, + src_file_path) @patch.object(vault.VaultEditor, '_editor_shell_command') def test_create_file(self, mock_editor_shell_command): diff --git a/test/units/parsing/yaml/test_loader.py b/test/units/parsing/yaml/test_loader.py index d6989f444b8..7a77241e9ec 100644 --- a/test/units/parsing/yaml/test_loader.py +++ b/test/units/parsing/yaml/test_loader.py @@ -284,11 +284,11 @@ class TestAnsibleLoaderVault(unittest.TestCase, YamlTestUtils): different_vault_string = data_from_yaml['different_secret'] self.assertEqual(vault_string, another_vault_string) - self.assertNotEquals(vault_string, different_vault_string) + self.assertNotEqual(vault_string, different_vault_string) # More testing of __eq__/__ne__ self.assertTrue('some string' != vault_string) - self.assertNotEquals('some string', vault_string) + self.assertNotEqual('some string', vault_string) # Note this is a compare of the str/unicode of these, they are different types # so we want to test self == other, and other == self etc diff --git a/test/units/parsing/yaml/test_objects.py b/test/units/parsing/yaml/test_objects.py index d4529eed9bd..f64b708f17b 100644 --- a/test/units/parsing/yaml/test_objects.py +++ b/test/units/parsing/yaml/test_objects.py @@ -52,7 +52,7 @@ class TestAnsibleVaultUnicodeNoVault(unittest.TestCase, YamlTestUtils): self.assertIsInstance(avu, objects.AnsibleVaultEncryptedUnicode) self.assertTrue(avu.vault is None) # AnsibleVaultEncryptedUnicode without a vault should never == any string - self.assertNotEquals(avu, seq) + self.assertNotEqual(avu, seq) def assert_values(self, seq): avu = objects.AnsibleVaultEncryptedUnicode(seq) diff --git a/test/units/playbook/test_base.py b/test/units/playbook/test_base.py index 648200afc1d..de3412e5db6 100644 --- a/test/units/playbook/test_base.py +++ b/test/units/playbook/test_base.py @@ -480,7 +480,7 @@ class TestBaseSubClass(TestBase): def test_attr_dict_string(self): test_value = 'just_some_random_string' ds = {'test_attr_dict': test_value} - self.assertRaisesRegexp(AnsibleParserError, 'is not a dictionary', self._base_validate, ds) + self.assertRaisesRegex(AnsibleParserError, 'is not a dictionary', self._base_validate, ds) def test_attr_class(self): esc = ExampleSubClass() @@ -503,14 +503,14 @@ class TestBaseSubClass(TestBase): def test_attr_class_post_validate_class_not_instance(self): not_a_esc = ExampleSubClass ds = {'test_attr_class_post_validate': not_a_esc} - self.assertRaisesRegexp(AnsibleParserError, 'is not a valid.*got a.*Meta.*instead', - self._base_validate, ds) + self.assertRaisesRegex(AnsibleParserError, 'is not a valid.*got a.*Meta.*instead', + self._base_validate, ds) def test_attr_class_post_validate_wrong_class(self): not_a_esc = 37 ds = {'test_attr_class_post_validate': not_a_esc} - self.assertRaisesRegexp(AnsibleParserError, 'is not a valid.*got a.*int.*instead', - self._base_validate, ds) + self.assertRaisesRegex(AnsibleParserError, 'is not a valid.*got a.*int.*instead', + self._base_validate, ds) def test_attr_remote_user(self): ds = {'remote_user': 'testuser'} @@ -599,8 +599,8 @@ class TestBaseSubClass(TestBase): bsc.load_data(ds) fake_loader = DictDataLoader({}) templar = Templar(loader=fake_loader) - self.assertRaisesRegexp(AnsibleParserError, 'cannot have empty values', - bsc.post_validate, templar) + self.assertRaisesRegex(AnsibleParserError, 'cannot have empty values', + bsc.post_validate, templar) def test_attr_unknown(self): a_list = ['some string'] diff --git a/test/units/playbook/test_conditional.py b/test/units/playbook/test_conditional.py index 53811b6bd31..07acb2f9d76 100644 --- a/test/units/playbook/test_conditional.py +++ b/test/units/playbook/test_conditional.py @@ -50,8 +50,8 @@ class TestConditional(unittest.TestCase): def test_undefined(self): when = [u"{{ some_undefined_thing }}"] - self.assertRaisesRegexp(errors.AnsibleError, "The conditional check '{{ some_undefined_thing }}' failed", - self._eval_con, when, {}) + self.assertRaisesRegex(errors.AnsibleError, "The conditional check '{{ some_undefined_thing }}' failed", + self._eval_con, when, {}) def test_defined(self): variables = {'some_defined_thing': True} @@ -100,12 +100,12 @@ class TestConditional(unittest.TestCase): when = [u"some_dict.some_dict_key1 == hostvars['host3']"] # self._eval_con(when, variables) - self.assertRaisesRegexp(errors.AnsibleError, - r"The conditional check 'some_dict.some_dict_key1 == hostvars\['host3'\]' failed", - # "The conditional check 'some_dict.some_dict_key1 == hostvars['host3']' failed", - # "The conditional check 'some_dict.some_dict_key1 == hostvars['host3']' failed.", - self._eval_con, - when, variables) + self.assertRaisesRegex(errors.AnsibleError, + r"The conditional check 'some_dict.some_dict_key1 == hostvars\['host3'\]' failed", + # "The conditional check 'some_dict.some_dict_key1 == hostvars['host3']' failed", + # "The conditional check 'some_dict.some_dict_key1 == hostvars['host3']' failed.", + self._eval_con, + when, variables) def test_dict_undefined_values_bare(self): variables = {'dict_value': 1, @@ -116,10 +116,10 @@ class TestConditional(unittest.TestCase): # raises an exception when a non-string conditional is passed to extract_defined_undefined() when = [u"some_defined_dict_with_undefined_values"] - self.assertRaisesRegexp(errors.AnsibleError, - "The conditional check 'some_defined_dict_with_undefined_values' failed.", - self._eval_con, - when, variables) + self.assertRaisesRegex(errors.AnsibleError, + "The conditional check 'some_defined_dict_with_undefined_values' failed.", + self._eval_con, + when, variables) def test_dict_undefined_values_is_defined(self): variables = {'dict_value': 1, @@ -129,10 +129,10 @@ class TestConditional(unittest.TestCase): }} when = [u"some_defined_dict_with_undefined_values is defined"] - self.assertRaisesRegexp(errors.AnsibleError, - "The conditional check 'some_defined_dict_with_undefined_values is defined' failed.", - self._eval_con, - when, variables) + self.assertRaisesRegex(errors.AnsibleError, + "The conditional check 'some_defined_dict_with_undefined_values is defined' failed.", + self._eval_con, + when, variables) def test_is_defined(self): variables = {'some_defined_thing': True} @@ -195,10 +195,10 @@ class TestConditional(unittest.TestCase): u'hostvars["some_host"] is defined', u"{{ compare_targets.triple }} is defined", u"{{ compare_targets.quadruple }} is defined"] - self.assertRaisesRegexp(errors.AnsibleError, - "The conditional check '{{ compare_targets.triple }} is defined' failed", - self._eval_con, - when, variables) + self.assertRaisesRegex(errors.AnsibleError, + "The conditional check '{{ compare_targets.triple }} is defined' failed", + self._eval_con, + when, variables) def test_is_hostvars_host_is_defined(self): variables = {'hostvars': {'some_host': {}, }} diff --git a/test/units/playbook/test_helpers.py b/test/units/playbook/test_helpers.py index 8574cb4c5b9..c177a662819 100644 --- a/test/units/playbook/test_helpers.py +++ b/test/units/playbook/test_helpers.py @@ -107,30 +107,30 @@ class TestLoadListOfTasks(unittest.TestCase, MixinForMocks): def test_empty_task(self): ds = [{}] - self.assertRaisesRegexp(errors.AnsibleParserError, - "no module/action detected in task", - helpers.load_list_of_tasks, - ds, play=self.mock_play, - variable_manager=self.mock_variable_manager, loader=self.fake_loader) + self.assertRaisesRegex(errors.AnsibleParserError, + "no module/action detected in task", + helpers.load_list_of_tasks, + ds, play=self.mock_play, + variable_manager=self.mock_variable_manager, loader=self.fake_loader) def test_empty_task_use_handlers(self): ds = [{}] - self.assertRaisesRegexp(errors.AnsibleParserError, - "no module/action detected in task.", - helpers.load_list_of_tasks, - ds, - use_handlers=True, - play=self.mock_play, - variable_manager=self.mock_variable_manager, - loader=self.fake_loader) + self.assertRaisesRegex(errors.AnsibleParserError, + "no module/action detected in task.", + helpers.load_list_of_tasks, + ds, + use_handlers=True, + play=self.mock_play, + variable_manager=self.mock_variable_manager, + loader=self.fake_loader) def test_one_bogus_block(self): ds = [{'block': None}] - self.assertRaisesRegexp(errors.AnsibleParserError, - "A malformed block was encountered", - helpers.load_list_of_tasks, - ds, play=self.mock_play, - variable_manager=self.mock_variable_manager, loader=self.fake_loader) + self.assertRaisesRegex(errors.AnsibleParserError, + "A malformed block was encountered", + helpers.load_list_of_tasks, + ds, play=self.mock_play, + variable_manager=self.mock_variable_manager, loader=self.fake_loader) def test_unknown_action(self): action_name = 'foo_test_unknown_action' @@ -172,11 +172,11 @@ class TestLoadListOfTasks(unittest.TestCase, MixinForMocks): def test_one_bogus_block_use_handlers(self): ds = [{'block': True}] - self.assertRaisesRegexp(errors.AnsibleParserError, - "A malformed block was encountered", - helpers.load_list_of_tasks, - ds, play=self.mock_play, use_handlers=True, - variable_manager=self.mock_variable_manager, loader=self.fake_loader) + self.assertRaisesRegex(errors.AnsibleParserError, + "A malformed block was encountered", + helpers.load_list_of_tasks, + ds, play=self.mock_play, use_handlers=True, + variable_manager=self.mock_variable_manager, loader=self.fake_loader) def test_one_bogus_include(self): ds = [{'include': 'somefile.yml'}] @@ -320,11 +320,11 @@ class TestLoadListOfRoles(unittest.TestCase, MixinForMocks): def test_empty_role(self): ds = [{}] - self.assertRaisesRegexp(errors.AnsibleError, - "role definitions must contain a role name", - helpers.load_list_of_roles, - ds, self.mock_play, - variable_manager=self.mock_variable_manager, loader=self.fake_role_loader) + self.assertRaisesRegex(errors.AnsibleError, + "role definitions must contain a role name", + helpers.load_list_of_roles, + ds, self.mock_play, + variable_manager=self.mock_variable_manager, loader=self.fake_role_loader) def test_empty_role_just_name(self): ds = [{'name': 'bogus_role'}] @@ -359,16 +359,16 @@ class TestLoadListOfBlocks(unittest.TestCase, MixinForMocks): def test_empty_block(self): ds = [{}] mock_play = MagicMock(name='MockPlay') - self.assertRaisesRegexp(errors.AnsibleParserError, - "no module/action detected in task", - helpers.load_list_of_blocks, - ds, mock_play, - parent_block=None, - role=None, - task_include=None, - use_handlers=False, - variable_manager=None, - loader=None) + self.assertRaisesRegex(errors.AnsibleParserError, + "no module/action detected in task", + helpers.load_list_of_blocks, + ds, mock_play, + parent_block=None, + role=None, + task_include=None, + use_handlers=False, + variable_manager=None, + loader=None) def test_block_unknown_action(self): ds = [{'action': 'foo', 'collections': []}] diff --git a/test/units/plugins/action/test_action.py b/test/units/plugins/action/test_action.py index 26c86bd616a..3296c82bb96 100644 --- a/test/units/plugins/action/test_action.py +++ b/test/units/plugins/action/test_action.py @@ -346,7 +346,7 @@ class TestActionBase(unittest.TestCase): self.assertEqual(runWithNoExpectation(execute), remote_paths) def assertThrowRegex(regex, execute=False): - self.assertRaisesRegexp( + self.assertRaisesRegex( AnsibleError, regex, action_base._fixup_perms2, diff --git a/test/units/plugins/cache/test_cache.py b/test/units/plugins/cache/test_cache.py index c4e0079a482..384dba88b72 100644 --- a/test/units/plugins/cache/test_cache.py +++ b/test/units/plugins/cache/test_cache.py @@ -185,9 +185,9 @@ class TestFactCache(unittest.TestCase): # See https://github.com/ansible/ansible/issues/18751 # Note no fact_connection config set, so this will fail with mock.patch('ansible.constants.CACHE_PLUGIN', 'json'): - self.assertRaisesRegexp(AnsibleError, - "Unable to load the facts cache plugin.*json.*", - FactCache) + self.assertRaisesRegex(AnsibleError, + "Unable to load the facts cache plugin.*json.*", + FactCache) def test_update(self): self.cache.update({'cache_key': {'key2': 'updatedvalue'}}) diff --git a/test/units/plugins/callback/test_callback.py b/test/units/plugins/callback/test_callback.py index c2ffbb4d880..6dc6842e720 100644 --- a/test/units/plugins/callback/test_callback.py +++ b/test/units/plugins/callback/test_callback.py @@ -56,7 +56,7 @@ class TestCallback(unittest.TestCase): def test_host_label(self): result = TaskResult(host=Host('host1'), task=mock_task, return_data={}) - self.assertEquals(CallbackBase.host_label(result), 'host1') + self.assertEqual(CallbackBase.host_label(result), 'host1') def test_host_label_delegated(self): mock_task.delegate_to = 'host2' @@ -65,7 +65,7 @@ class TestCallback(unittest.TestCase): task=mock_task, return_data={'_ansible_delegated_vars': {'ansible_host': 'host2'}}, ) - self.assertEquals(CallbackBase.host_label(result), 'host1 -> host2') + self.assertEqual(CallbackBase.host_label(result), 'host1 -> host2') # TODO: import callback module so we can patch callback.cli/callback.C diff --git a/test/units/template/test_templar.py b/test/units/template/test_templar.py index 8dd0feb5bf6..046625bfe5a 100644 --- a/test/units/template/test_templar.py +++ b/test/units/template/test_templar.py @@ -219,10 +219,10 @@ class TestTemplarTemplate(BaseTemplar, unittest.TestCase): def test_weird(self): data = u'''1 2 #}huh{# %}ddfg{% }}dfdfg{{ {%what%} {{#foo#}} {%{bar}%} {#%blip%#} {{asdfsd%} 3 4 {{foo}} 5 6 7''' - self.assertRaisesRegexp(AnsibleError, - 'template error while templating string', - self.templar.template, - data) + self.assertRaisesRegex(AnsibleError, + 'template error while templating string', + self.templar.template, + data) def test_template_with_error(self): """Check that AnsibleError is raised, fail if an unhandled exception is raised""" @@ -297,21 +297,21 @@ class TestTemplarMisc(BaseTemplar, unittest.TestCase): class TestTemplarLookup(BaseTemplar, unittest.TestCase): def test_lookup_missing_plugin(self): - self.assertRaisesRegexp(AnsibleError, - r'lookup plugin \(not_a_real_lookup_plugin\) not found', - self.templar._lookup, - 'not_a_real_lookup_plugin', - 'an_arg', a_keyword_arg='a_keyword_arg_value') + self.assertRaisesRegex(AnsibleError, + r'lookup plugin \(not_a_real_lookup_plugin\) not found', + self.templar._lookup, + 'not_a_real_lookup_plugin', + 'an_arg', a_keyword_arg='a_keyword_arg_value') def test_lookup_list(self): res = self.templar._lookup('list', 'an_arg', 'another_arg') self.assertEqual(res, 'an_arg,another_arg') def test_lookup_jinja_undefined(self): - self.assertRaisesRegexp(AnsibleUndefinedVariable, - "'an_undefined_jinja_var' is undefined", - self.templar._lookup, - 'list', '{{ an_undefined_jinja_var }}') + self.assertRaisesRegex(AnsibleUndefinedVariable, + "'an_undefined_jinja_var' is undefined", + self.templar._lookup, + 'list', '{{ an_undefined_jinja_var }}') def test_lookup_jinja_defined(self): res = self.templar._lookup('list', '{{ some_var }}') @@ -319,18 +319,18 @@ class TestTemplarLookup(BaseTemplar, unittest.TestCase): # self.assertIsInstance(res, AnsibleUnsafe) def test_lookup_jinja_dict_string_passed(self): - self.assertRaisesRegexp(AnsibleError, - "with_dict expects a dict", - self.templar._lookup, - 'dict', - '{{ some_var }}') + self.assertRaisesRegex(AnsibleError, + "with_dict expects a dict", + self.templar._lookup, + 'dict', + '{{ some_var }}') def test_lookup_jinja_dict_list_passed(self): - self.assertRaisesRegexp(AnsibleError, - "with_dict expects a dict", - self.templar._lookup, - 'dict', - ['foo', 'bar']) + self.assertRaisesRegex(AnsibleError, + "with_dict expects a dict", + self.templar._lookup, + 'dict', + ['foo', 'bar']) def test_lookup_jinja_kwargs(self): res = self.templar._lookup('list', 'blip', random_keyword='12345') @@ -342,12 +342,12 @@ class TestTemplarLookup(BaseTemplar, unittest.TestCase): self.assertEqual(res, ["blip"]) def test_lookup_jinja_list_wantlist_undefined(self): - self.assertRaisesRegexp(AnsibleUndefinedVariable, - "'some_undefined_var' is undefined", - self.templar._lookup, - 'list', - '{{ some_undefined_var }}', - wantlist=True) + self.assertRaisesRegex(AnsibleUndefinedVariable, + "'some_undefined_var' is undefined", + self.templar._lookup, + 'list', + '{{ some_undefined_var }}', + wantlist=True) def test_lookup_jinja_list_wantlist_unsafe(self): res = self.templar._lookup('list', '{{ some_unsafe_var }}', wantlist=True)