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"])
