def test_highstate(): """Test transactional_update.highstage""" transactional_update_highstate_mock = MagicMock() transactional_update_highstate_mock.return_value = ( transactional_update_highstate_mock) _create_and_execute_salt_state_mock = MagicMock(return_value="result") opts_mock = { "hash_type": "md5", } salt_mock = { "saltutil.is_running": MagicMock(return_value=[]), } get_sls_opts_mock = MagicMock(return_value=opts_mock) with patch.dict(tu.__opts__, opts_mock), patch.dict( statemod.__salt__, salt_mock ), patch("salt.utils.state.get_sls_opts", get_sls_opts_mock), patch( "salt.fileclient.get_file_client", MagicMock() ), patch( "salt.modules.transactional_update.TransactionalUpdateHighstate", transactional_update_highstate_mock, ), patch( "salt.modules.transactional_update._create_and_execute_salt_state", _create_and_execute_salt_state_mock, ): assert tu.highstate() == "result" _create_and_execute_salt_state_mock.assert_called_once()
def test_highstate_queue_true(): """Test transactional_update.highstage""" transactional_update_highstate_mock = MagicMock() transactional_update_highstate_mock.return_value = ( transactional_update_highstate_mock) _create_and_execute_salt_state_mock = MagicMock(return_value="result") opts_mock = { "hash_type": "md5", } salt_mock = { "saltutil.is_running": MagicMock(side_effect=[ [{ "fun": "state.running", "pid": "4126", "jid": "20150325123407204096", }], [], ]), } get_sls_opts_mock = MagicMock(return_value=opts_mock) with patch.dict(tu.__opts__, opts_mock), patch.dict( statemod.__salt__, salt_mock ), patch("salt.utils.state.get_sls_opts", get_sls_opts_mock), patch( "salt.fileclient.get_file_client", MagicMock() ), patch( "salt.modules.transactional_update.TransactionalUpdateHighstate", transactional_update_highstate_mock, ), patch( "salt.modules.transactional_update._create_and_execute_salt_state", _create_and_execute_salt_state_mock, ): assert tu.highstate(queue=True) == "result" _create_and_execute_salt_state_mock.assert_called_once()
class UnregisterVirtualMachineTestCase(TestCase): '''Tests for salt.utils.vmware.unregister_vm''' def setUp(self): self.mock_vm_unregister = MagicMock() self.mock_vm_ref = MagicMock(UnregisterVM=self.mock_vm_unregister) def test_unregister_vm_task_call(self): vmware.unregister_vm(self.mock_vm_ref) self.mock_vm_unregister.assert_called_once() def test_unregister_vm_raise_vim_fault(self): exception = vim.fault.VimFault() exception.msg = 'vim.fault.VimFault' self.mock_vm_ref.UnregisterVM = MagicMock(side_effect=exception) with self.assertRaises(VMwareApiError) as exc: vmware.unregister_vm(self.mock_vm_ref) self.assertEqual(exc.exception.strerror, 'vim.fault.VimFault') def test_unregister_vm_raise_runtime_fault(self): exception = vmodl.RuntimeFault() exception.msg = 'vmodl.RuntimeFault' self.mock_vm_ref.UnregisterVM = MagicMock(side_effect=exception) with self.assertRaises(VMwareRuntimeError) as exc: vmware.unregister_vm(self.mock_vm_ref) self.assertEqual(exc.exception.strerror, 'vmodl.RuntimeFault')
def test_exists_change_index_success(name): """ Tests win_path.exists when the directory is already in the PATH and needs to be moved to a different position (successful run). """ add_mock = MagicMock(return_value=True) rehash_mock = MagicMock(return_value=True) dunder_salt = { "win_path.get_path": MagicMock(side_effect=[["foo", "bar", "baz", name], [name, "foo", "bar", "baz"]]), "win_path.add": add_mock, "win_path.rehash": rehash_mock, } dunder_opts = {"test": False} with patch.dict(win_path.__salt__, dunder_salt), patch.dict(win_path.__opts__, dunder_opts): ret = win_path.exists(name, index=0) add_mock.assert_called_once_with(name, index=0, rehash=False) rehash_mock.assert_called_once() assert ret == { "name": name, "changes": { "index": { "old": 3, "new": 0 } }, "result": True, "comment": "Moved {} from index 3 to 0.".format(name), }
def test_handle_payload_metaproxy_called(self): """ Tests that when the _handle_payload function is called, _metaproxy_call is also called. """ mock_opts = salt.config.DEFAULT_MINION_OPTS.copy() mock_opts.update(salt.config.DEFAULT_PROXY_MINION_OPTS) mock_data = {"fun": "foo.bar", "jid": 123} mock_jid_queue = [123] proxy_minion = salt.minion.ProxyMinion( mock_opts, jid_queue=copy.copy(mock_jid_queue), io_loop=salt.ext.tornado.ioloop.IOLoop(), ) mock_metaproxy_call = MagicMock() with patch( "salt.minion._metaproxy_call", return_value=mock_metaproxy_call, autospec=True, ): try: ret = proxy_minion._handle_decoded_payload(mock_data).result() self.assertEqual(proxy_minion.jid_queue, mock_jid_queue) mock_metaproxy_call.assert_called_once() finally: proxy_minion.destroy()
def test_single_queue_true(): """Test transactional_update.single""" ssh_state_mock = MagicMock() ssh_state_mock.return_value = ssh_state_mock ssh_state_mock.verify_data.return_value = None _create_and_execute_salt_state_mock = MagicMock(return_value="result") opts_mock = { "hash_type": "md5", } salt_mock = { "saltutil.is_running": MagicMock(side_effect=[ [{ "fun": "state.running", "pid": "4126", "jid": "20150325123407204096", }], [], ]), } get_sls_opts_mock = MagicMock(return_value=opts_mock) with patch.dict(tu.__opts__, opts_mock), patch.dict( statemod.__salt__, salt_mock ), patch("salt.utils.state.get_sls_opts", get_sls_opts_mock), patch( "salt.fileclient.get_file_client", MagicMock() ), patch("salt.client.ssh.state.SSHState", ssh_state_mock), patch( "salt.modules.transactional_update._create_and_execute_salt_state", _create_and_execute_salt_state_mock, ): assert tu.single("pkg.installed", name="emacs", queue=True) == "result" _create_and_execute_salt_state_mock.assert_called_once()
def test_datasource_exist_create_datasource_good_code(self): jboss_config = {'cli_path': '/home/ch44d/Desktop/wildfly-18.0.0.Final/bin/jboss-cli.sh', 'controller': '127.0.0.1: 9990', 'cli_user': '******', 'cli_password': '******'} datasource_properties = {'driver - name': 'h2', 'connection - url': 'jdbc:sqlserver://127.0.0.1:1433;DatabaseName=test_s2', 'jndi - name': 'java:/home/ch44d/Desktop/sqljdbc_7.4/enu/mssql-jdbc-7.4.1.jre8.jar', 'user - name': 'user', 'password': '******', 'use - java - context': True} read_datasource = MagicMock(return_value={'success': False, 'err_code': 'WFLYCTL0216'}) error_msg = 'Error: -1' create_datasource = MagicMock(return_value={'success': False, 'stdout': error_msg}) with patch.dict(jboss7.__salt__, {'jboss7.read_datasource': read_datasource, 'jboss7.create_datasource': create_datasource}): ret = jboss7.datasource_exists("SQL", jboss_config, datasource_properties) self.assertTrue('result' in ret) self.assertFalse(ret['result']) self.assertTrue('comment' in ret) self.assertTrue(error_msg in ret['comment']) read_datasource.assert_called_once() create_datasource.assert_called_once()
def test_create(self): mock = MagicMock(return_value='salt') with patch.dict(mdadm.__salt__, {'cmd.run': mock}), \ patch('salt.utils.which', lambda exe: exe): ret = mdadm.create('/dev/md0', 5, devices=['/dev/sdb1', '/dev/sdc1', '/dev/sdd1'], test_mode=False, force=True, chunk=256) self.assertEqual('salt', ret) # Only available in 3.6 and above on py3 if hasattr(mock, 'assert_called_once'): mock.assert_called_once() args, kwargs = mock.call_args # expected cmd is # mdadm -C /dev/md0 -R -v --chunk 256 --force -l 5 -e default -n 3 /dev/sdb1 /dev/sdc1 /dev/sdd1 # where args between -v and -l could be in any order self.assertEqual(len(args), 1) self.assertEqual(len(args[0]), 17) self.assertEqual(args[0][:5], ['mdadm', '-C', '/dev/md0', '-R', '-v']) self.assertEqual(args[0][8:], [ '-l', '5', '-e', 'default', '-n', '3', '/dev/sdb1', '/dev/sdc1', '/dev/sdd1' ]) self.assertEqual(sorted(args[0][5:8]), sorted(['--chunk', '256', '--force'])) self.assertIn('--chunk 256', ' '.join(args[0][5:8])) self.assertEqual(kwargs, {'python_shell': False})
class DeleteVirtualMachineTestCase(TestCase): '''Tests for salt.utils.vmware.delete_vm''' def setUp(self): self.mock_task = MagicMock() self.mock_vm_destroy_task = MagicMock(return_value=self.mock_task) self.mock_vm_ref = MagicMock(Destroy_Task=self.mock_vm_destroy_task) def test_destroy_vm_task_call(self): vmware.delete_vm(self.mock_vm_ref) self.mock_vm_destroy_task.assert_called_once() def test_destroy_vm_raise_vim_fault(self): exception = vim.fault.VimFault() exception.msg = 'vim.fault.VimFault' self.mock_vm_ref.Destroy_Task = MagicMock(side_effect=exception) with self.assertRaises(VMwareApiError) as exc: vmware.delete_vm(self.mock_vm_ref) self.assertEqual(exc.exception.strerror, 'vim.fault.VimFault') def test_destroy_vm_raise_runtime_fault(self): exception = vmodl.RuntimeFault() exception.msg = 'vmodl.RuntimeFault' self.mock_vm_ref.Destroy_Task = MagicMock(side_effect=exception) with self.assertRaises(VMwareRuntimeError) as exc: vmware.delete_vm(self.mock_vm_ref) self.assertEqual(exc.exception.strerror, 'vmodl.RuntimeFault') def test_destroy_vm_wait_for_task(self): mock_wait_for_task = MagicMock() with patch('salt.utils.vmware.get_managed_object_name', MagicMock(return_value='my_vm')): with patch('salt.utils.vmware.wait_for_task', mock_wait_for_task): vmware.delete_vm(self.mock_vm_ref) mock_wait_for_task.assert_called_once_with(self.mock_task, 'my_vm', 'Destroy Task')
def test_call_success_reboot(): """Test transactional_update.chroot when succeed and reboot""" pending_transaction_mock = MagicMock(return_value=True) reboot_mock = MagicMock() utils_mock = { "thin.gen_thin": MagicMock(return_value="/salt-thin.tgz"), "files.rm_rf": MagicMock(), "json.find_json": MagicMock(return_value={"return": "result"}), } opts_mock = {"cachedir": "/var/cache/salt/minion"} salt_mock = { "cmd.run": MagicMock(return_value=""), "config.option": MagicMock(), "cmd.run_all": MagicMock(return_value={ "retcode": 0, "stdout": "" }), } with patch.dict(tu.__utils__, utils_mock), patch.dict( tu.__opts__, opts_mock), patch.dict(tu.__salt__, salt_mock), patch( "salt.modules.transactional_update.pending_transaction", pending_transaction_mock, ), patch("salt.modules.transactional_update.reboot", reboot_mock): assert (tu.call("transactional_update.dup", activate_transaction=True) == "result") utils_mock["thin.gen_thin"].assert_called_once() salt_mock["config.option"].assert_called() salt_mock["cmd.run"].assert_called_once() salt_mock["cmd.run_all"].assert_called_with([ "transactional-update", "--non-interactive", "--drop-if-no-change", "--no-selfupdate", "--continue", "--quiet", "run", "python{}".format(sys.version_info[0]), "/var/cache/salt/minion/tmp01/salt-call", "--metadata", "--local", "--log-file", "/var/cache/salt/minion/tmp01/log", "--cachedir", "/var/cache/salt/minion/tmp01/cache", "--out", "json", "-l", "quiet", "--", "transactional_update.dup", ]) utils_mock["files.rm_rf"].assert_called_once() pending_transaction_mock.assert_called_once() reboot_mock.assert_called_once()
def test_virtual_update_restart_state_called(self): """ Test - Update restart state is called when empty dir """ mock_cmd = MagicMock() with patch.dict(opkg.__grains__, {"os_family": "NILinuxRT"}): with patch.object(os, "makedirs", MagicMock(return_value=True)): with patch.object(os, "listdir", MagicMock(return_value=[])): with patch.object(opkg, "_update_nilrt_restart_state", mock_cmd): opkg.__virtual__() mock_cmd.assert_called_once()
def test_datasource_exist_create_datasource_good_code(self): jboss_config = { "cli_path": "/home/ch44d/Desktop/wildfly-18.0.0.Final/bin/jboss-cli.sh", "controller": "127.0.0.1: 9990", "cli_user": "******", "cli_password": "******", } datasource_properties = { "driver - name": "h2", "connection - url": "jdbc:sqlserver://127.0.0.1:1433;DatabaseName=test_s2", "jndi - name": ("java:/home/ch44d/Desktop/sqljdbc_7.4/enu/mssql-jdbc-7.4.1.jre8.jar" ), "user - name": "user", "password": "******", "use - java - context": True, } read_datasource = MagicMock(return_value={ "success": False, "err_code": "WFLYCTL0216" }) error_msg = "Error: -1" create_datasource = MagicMock(return_value={ "success": False, "stdout": error_msg }) with patch.dict( jboss7.__salt__, { "jboss7.read_datasource": read_datasource, "jboss7.create_datasource": create_datasource, }, ): ret = jboss7.datasource_exists("SQL", jboss_config, datasource_properties) self.assertTrue("result" in ret) self.assertFalse(ret["result"]) self.assertTrue("comment" in ret) self.assertTrue(error_msg in ret["comment"]) read_datasource.assert_called_once() create_datasource.assert_called_once()
def test_django_admin_cli_createsuperuser(self): mock = MagicMock() with patch.dict(djangomod.__salt__, {'cmd.run': mock}): djangomod.createsuperuser( 'settings.py', 'testuser', '*****@*****.**' ) mock.assert_called_once() args, kwargs = mock.call_args # cmdline arguments are extracted from a kwargs dict so order isn't guaranteed. self.assertEqual(len(args), 1) self.assertTrue(args[0].startswith('django-admin.py createsuperuser --')) self.assertEqual(set(args[0].split()), set('django-admin.py createsuperuser --settings=settings.py --noinput ' '--username=testuser [email protected]'.split())) self.assertDictEqual(kwargs, {'python_shell': False, 'env': None})
def test_install_restart(): """ Test win_servermanager.install when restart=True """ mock_out = { "Success": True, "RestartNeeded": 1, "FeatureResult": [{ "Id": 338, "Name": "XPS-Viewer", "DisplayName": "XPS Viewer", "Success": True, "RestartNeeded": True, "Message": "", "SkipReason": 0, }], "ExitCode": 0, } expected = { "ExitCode": 0, "RestartNeeded": True, "Restarted": True, "Features": { "XPS-Viewer": { "DisplayName": "XPS Viewer", "Message": "", "RestartNeeded": True, "SkipReason": 0, "Success": True, } }, "Success": True, } mock_reboot = MagicMock(return_value=True) with patch.object(win_servermanager, "_pshell_json", return_value=mock_out), patch.dict( win_servermanager.__salt__, {"system.reboot": mock_reboot}): result = win_servermanager.install("XPS-Viewer", restart=True) mock_reboot.assert_called_once() assert result == expected
def test_datasource_exist_create_datasource_bad_code(self): jboss_config = { "cli_path": "/home/ch44d/Desktop/wildfly-18.0.0.Final/bin/jboss-cli.sh", "controller": "127.0.0.1: 9990", "cli_user": "******", "cli_password": "******", } datasource_properties = { "driver - name": "h2", "connection - url": "jdbc:sqlserver://127.0.0.1:1433;DatabaseName=test_s2", "jndi - name": ("java:/home/ch44d/Desktop/sqljdbc_7.4/enu/mssql-jdbc-7.4.1.jre8.jar" ), "user - name": "user", "password": "******", "use - java - context": True, } read_datasource = MagicMock( return_value={ "success": False, "err_code": "WFLYCTL0217", "failure-description": "Something happened", }) with patch.dict(jboss7.__salt__, {"jboss7.read_datasource": read_datasource}): self.assertRaises( CommandExecutionError, jboss7.datasource_exists, "SQL", jboss_config, datasource_properties, ) read_datasource.assert_called_once()
def test_call_success_reboot(): """Test transactional_update.chroot when succeed and reboot""" pending_transaction_mock = MagicMock(return_value=True) reboot_mock = MagicMock() utils_mock = { "json.find_json": MagicMock(return_value={"return": "result"}), } salt_mock = { "cmd.run_all": MagicMock(return_value={ "retcode": 0, "stdout": "" }), } with patch.dict(tu.__utils__, utils_mock), patch.dict( tu.__salt__, salt_mock), patch.dict(tu.__salt__, salt_mock), patch( "salt.modules.transactional_update.pending_transaction", pending_transaction_mock, ), patch("salt.modules.transactional_update.reboot", reboot_mock): assert (tu.call("transactional_update.dup", activate_transaction=True) == "result") salt_mock["cmd.run_all"].assert_called_with([ "transactional-update", "--non-interactive", "--drop-if-no-change", "--no-selfupdate", "--continue", "--quiet", "run", "salt-call", "--out", "json", "-l", "quiet", "--no-return-event", "--", "transactional_update.dup", ]) pending_transaction_mock.assert_called_once() reboot_mock.assert_called_once()
def test_valid_async_args(self): mock_execute = MagicMock(return_value={}) mock_execute_async = MagicMock(return_value={}) mock_context = { "cassandra_cql_returner_cluster": MagicMock(return_value={}), "cassandra_cql_returner_session": MagicMock( execute=mock_execute, execute_async=mock_execute_async, prepare=lambda _: MagicMock(bind=lambda _: None), # mock prepared_statement row_factory=None, ), "cassandra_cql_prepared": {}, } kwargs = {"async": True} # to avoid syntax error in python 3.7 with patch.dict(cassandra_cql.__context__, mock_context): cassandra_cql.cql_query_with_prepare( "SELECT now() from system.local;", "select_now", [], **kwargs) mock_execute_async.assert_called_once()
def test_tune(self): mock = MagicMock( return_value= '712971264\n512\n512\n512\n0\n0\n88\n712971264\n365041287168\n512\n512' ) with patch.dict(disk.__salt__, {'cmd.run': mock}): mock_dump = MagicMock(return_value={'retcode': 0, 'stdout': ''}) with patch('salt.modules.disk.dump', mock_dump): kwargs = {'read-ahead': 512, 'filesystem-read-ahead': 1024} disk.tune('/dev/sda', **kwargs) mock.assert_called_once() args, kwargs = mock.call_args # Assert called once with either 'blockdev --setra 512 --setfra 512 /dev/sda' or # 'blockdev --setfra 512 --setra 512 /dev/sda' and python_shell=False kwarg. self.assertEqual(len(args), 1) self.assertTrue(args[0].startswith('blockdev ')) self.assertTrue(args[0].endswith(' /dev/sda')) self.assertIn(' --setra 512 ', args[0]) self.assertIn(' --setfra 1024 ', args[0]) self.assertEqual(len(args[0].split()), 6) self.assertEqual(kwargs, {'python_shell': False})
def test_datasource_exist_create_datasource_bad_code(self): jboss_config = {'cli_path': '/home/ch44d/Desktop/wildfly-18.0.0.Final/bin/jboss-cli.sh', 'controller': '127.0.0.1: 9990', 'cli_user': '******', 'cli_password': '******'} datasource_properties = {'driver - name': 'h2', 'connection - url': 'jdbc:sqlserver://127.0.0.1:1433;DatabaseName=test_s2', 'jndi - name': 'java:/home/ch44d/Desktop/sqljdbc_7.4/enu/mssql-jdbc-7.4.1.jre8.jar', 'user - name': 'user', 'password': '******', 'use - java - context': True} read_datasource = MagicMock(return_value={'success': False, 'err_code': 'WFLYCTL0217', 'failure-description': 'Something happened'}) with patch.dict(jboss7.__salt__, {'jboss7.read_datasource': read_datasource}): self.assertRaises(CommandExecutionError, jboss7.datasource_exists, 'SQL', jboss_config, datasource_properties) read_datasource.assert_called_once()
def test_single(): """Test transactional_update.single""" ssh_state_mock = MagicMock() ssh_state_mock.return_value = ssh_state_mock ssh_state_mock.verify_data.return_value = None _create_and_execute_salt_state_mock = MagicMock(return_value="result") opts_mock = { "hash_type": "md5", } salt_mock = { "saltutil.is_running": MagicMock(return_value=[]), } get_sls_opts_mock = MagicMock(return_value=opts_mock) with patch.dict(tu.__opts__, opts_mock), patch.dict( statemod.__salt__, salt_mock ), patch("salt.utils.state.get_sls_opts", get_sls_opts_mock), patch( "salt.fileclient.get_file_client", MagicMock() ), patch("salt.client.ssh.state.SSHState", ssh_state_mock), patch( "salt.modules.transactional_update._create_and_execute_salt_state", _create_and_execute_salt_state_mock, ): assert tu.single("pkg.installed", name="emacs") == "result" _create_and_execute_salt_state_mock.assert_called_once()
class CreateVirtualMachineTestCase(TestCase): '''Tests for salt.utils.vmware.create_vm''' def setUp(self): self.vm_name = 'fake_vm' self.mock_task = MagicMock() self.mock_config_spec = MagicMock() self.mock_resourcepool_object = MagicMock() self.mock_host_object = MagicMock() self.mock_vm_create_task = MagicMock(return_value=self.mock_task) self.mock_folder_object = MagicMock( CreateVM_Task=self.mock_vm_create_task) def test_create_vm_pool_task_call(self): vmware.create_vm(self.vm_name, self.mock_config_spec, self.mock_folder_object, self.mock_resourcepool_object) self.mock_vm_create_task.assert_called_once() def test_create_vm_host_task_call(self): vmware.create_vm(self.vm_name, self.mock_config_spec, self.mock_folder_object, self.mock_resourcepool_object, host_object=self.mock_host_object) self.mock_vm_create_task.assert_called_once() def test_create_vm_raise_no_permission(self): exception = vim.fault.NoPermission() exception.msg = 'vim.fault.NoPermission msg' self.mock_folder_object.CreateVM_Task = MagicMock( side_effect=exception) with self.assertRaises(VMwareApiError) as exc: vmware.create_vm(self.vm_name, self.mock_config_spec, self.mock_folder_object, self.mock_resourcepool_object) self.assertEqual(exc.exception.strerror, 'Not enough permissions. Required privilege: ') def test_create_vm_raise_vim_fault(self): exception = vim.fault.VimFault() exception.msg = 'vim.fault.VimFault msg' self.mock_folder_object.CreateVM_Task = MagicMock( side_effect=exception) with self.assertRaises(VMwareApiError) as exc: vmware.create_vm(self.vm_name, self.mock_config_spec, self.mock_folder_object, self.mock_resourcepool_object) self.assertEqual(exc.exception.strerror, 'vim.fault.VimFault msg') def test_create_vm_raise_runtime_fault(self): exception = vmodl.RuntimeFault() exception.msg = 'vmodl.RuntimeFault msg' self.mock_folder_object.CreateVM_Task = MagicMock( side_effect=exception) with self.assertRaises(VMwareRuntimeError) as exc: vmware.create_vm(self.vm_name, self.mock_config_spec, self.mock_folder_object, self.mock_resourcepool_object) self.assertEqual(exc.exception.strerror, 'vmodl.RuntimeFault msg') def test_create_vm_wait_for_task(self): mock_wait_for_task = MagicMock() with patch('salt.utils.vmware.wait_for_task', mock_wait_for_task): vmware.create_vm(self.vm_name, self.mock_config_spec, self.mock_folder_object, self.mock_resourcepool_object) mock_wait_for_task.assert_called_once_with(self.mock_task, self.vm_name, 'CreateVM Task', 10, 'info')
class X509FipsTestCase(TestCase, LoaderModuleMockMixin): def setup_loader_modules(self): self.file_managed_mock = MagicMock() self.file_managed_mock.return_value = {"changes": True} return { x509: { "__opts__": { "fips_mode": True }, "__salt__": { "x509.get_pem_entry": x509_mod.get_pem_entry, "x509.get_private_key_size": x509_mod.get_private_key_size, }, "__states__": { "file.managed": self.file_managed_mock }, } } @skipIf(not HAS_M2CRYPTO, "Skipping, M2Crypto is unavailable") def test_private_key_fips_mode(self): """ :return: """ test_key = dedent(""" -----BEGIN PRIVATE KEY----- MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDx7UUt0cPi5G51 FmRBhAZtZb5x6P0PFn7GwnLmSvLNhCsOcD/vq/yBUU62pknzmOjM5pgWTACZj66O GOFmWBg06v8+sqUbaF9PZ/CxQD5MogmQhYNgfyuopHWWgLXMub2hlP+15qGohkzg Tr/mXp2ohVAb6ihjqb7XV9MiZaLNVX+XWauM8SlhqXMiJyDUopEGbg2pLsHhIMcX 1twLlyDja+uDbCMZ4jDNB+wsWxTaPRH8KizfEabB1Cl+fdyD10pSAYcodOAnlkW+ G/DX2hwb/ZAM9B1SXTfZ3gzaIIbqXBEHcZQNXxHL7szBTVcOmfx/RPfOeRncytb9 Mit7RIBxAgMBAAECggEAD4Pi+uRIBsYVm2a7OURpURzEUPPbPtt3d/HCgqht1+ZR CJUEVK+X+wcm4Cnb9kZpL7LeMBfhtfdz/2LzGagurT4g7nlwg0h3TFVjJ0ryc+G0 cVNOsKKXPzKE5AkPH7kNw04V9Cl9Vpx+U6hZQEHzJHqgP5oNyw540cCtJriT700b fG1q3PYKWSkDwTiUnJTnVLybFIKQC6urxTeT2UWeiBadfDY7DjI4USfrQsqCfGMO uWPpOOJk5RIvw5r0Of2xvxV76xCgzVTkgtWjBRMTEkfeYx3019xKlQtAKoGbZd1T tF8DH0cDlnri4nG7YT8yYvx/LWVDg12E6IZij1X60QKBgQD7062JuQGEmTd99a7o 5TcgWYqDrmE9AEgJZjN+gnEPcsxc50HJaTQgrkV0oKrS8CMbStIymbzMKWifOj7o gvQBVecydq1AaXePt3gRe8vBFiP4cHjFcSegs9FDvdfJR36iHOBIgEp4DWvV1vgs +z82LT6Qy5kxUQvnlQ4dEaGdrQKBgQD175f0H4enRJ3BoWTrqt2mTAwtJcPsKmGD 9YfFB3H4+O2rEKP4FpBO5PFXZ0dqm54hDtxqyC/lSXorFCUjVUBero1ECGt6Gnn2 TSnhgk0VMxvhnc0GReIt4K9WrXGd0CMUDwIhFHj8kbb1X1yqt2hwyw7b10xFVStl sGv8CQB+VQKBgAF9q1VZZwzl61Ivli2CzeS/IvbMnX7C9ao4lK13EDxLLbKPG/CZ UtmurnKWUOyWx15t/viVuGxtAlWO/rhZriAj5g6CbVwoQ7DyIR/ZX8dw3h2mbNCe buGgruh7wz9J0RIcoadMOySiz7SgZS++/QzRD8HDstB77loco8zAQfixAoGBALDO FbTocfKbjrpkmBQg24YxR9OxQb/n3AEtI/VO2+38r4h6xxaUyhwd1S9bzWjkBXOI poeR8XTqNQ0BR422PTeUT3SohPPcUu/yG3jG3zmta47wjjPDS85lqEgtGvA0cPN7 srErcatJ6nlOnGUSw9/K65y6lFeH2lIZ2hfwNM2dAoGBAMVCc7i3AIhLp6UrGzjP 0ioCHCakpxfl8s1VQp55lhHlP6Y4RfqT72Zq7ScteTrisIAQyI9ot0gsuct2miQM nyDdyKGki/MPduGTzzWlBA7GZEHnxbAILH8kWJ7eE/Nh7zdF1CRts8utEO9L9S+0 lVz1j/xGOseQk4cVos681Wpw -----END PRIVATE KEY-----""") test_cert = dedent(""" -----BEGIN CERTIFICATE----- MIIDazCCAlOgAwIBAgIUAfATs1aodKw11Varh55msmU0LoowDQYJKoZIhvcNAQEL BQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0yMTAzMjMwMTM4MzdaFw0yMjAz MjMwMTM4MzdaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggEiMA0GCSqGSIb3DQEB AQUAA4IBDwAwggEKAoIBAQDx7UUt0cPi5G51FmRBhAZtZb5x6P0PFn7GwnLmSvLN hCsOcD/vq/yBUU62pknzmOjM5pgWTACZj66OGOFmWBg06v8+sqUbaF9PZ/CxQD5M ogmQhYNgfyuopHWWgLXMub2hlP+15qGohkzgTr/mXp2ohVAb6ihjqb7XV9MiZaLN VX+XWauM8SlhqXMiJyDUopEGbg2pLsHhIMcX1twLlyDja+uDbCMZ4jDNB+wsWxTa PRH8KizfEabB1Cl+fdyD10pSAYcodOAnlkW+G/DX2hwb/ZAM9B1SXTfZ3gzaIIbq XBEHcZQNXxHL7szBTVcOmfx/RPfOeRncytb9Mit7RIBxAgMBAAGjUzBRMB0GA1Ud DgQWBBT0qx4KLhozvuWAI9peT/utYV9FITAfBgNVHSMEGDAWgBT0qx4KLhozvuWA I9peT/utYV9FITAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQDx tWvUyGfEwJJg1ViBa10nVhg5sEc6KfqcPzc2GvatIGJlAbc3b1AYu6677X04SQNA dYRA2jcZcKudy6eolPJow6SDpkt66IqciZYdbQE5h9elnwpZxmXlJTQTB9cEwyIk 2em5DKpdIwa9rRDlbAjAVJb3015MtpKRu2gsQ7gl5X2U3K+DFsWtBPf+0xiJqUiq rd7tiHF/zylubSyH/LVONJZ6+/oT/qzJfxfpvygtQWcu4b2zzME/FPenMA8W6Rau ZYycQfpMVc7KwqF5/wfjnkmfxoFKnkD7WQ3qFCJ/xULk/Yn1hrvNeIr+khX3qKQi Y3BMA5m+J+PZrNy7EQSa -----END CERTIFICATE----- """) fp, name = tempfile.mkstemp() with salt.utils.files.fopen(name, "w") as fd: fd.write(test_key) fd.write(test_cert) ret = x509.private_key_managed(name) self.file_managed_mock.assert_called_once() assert (self.file_managed_mock.call_args.kwargs["contents"].strip() == test_key.strip()) def test_certificate_info_matches(self): cert_info = {"MD5 Finger Print": ""} required_info = {"MD5 Finger Print": ""} ret = x509._certificate_info_matches(cert_info, required_info) assert ret == (False, ["MD5 Finger Print"])