def test_setup_show(self):
'''
Test if setup_show function work well
Test data is get from drbd-9.0.16/drbd-utils-9.6.0
'''
# Test 1: Return code is 0
ret = [{
'_this_host': {
'node-id':
1,
'volumes': [{
'device_minor': 5,
'disk': {
'on-io-error': 'pass_on'
},
'meta-disk': 'internal',
'volume_nr': 0
}]
},
'connections': [{
'_peer_node_id':
2,
'net': {
'_name': 'salt-node3',
'ping-timeout': '10'
},
'path': {
'_remote_host': 'ipv4 192.168.10.103:7990',
'_this_host': 'ipv4 192.168.10.102:7990'
},
'volumes': [{
'disk': {
'c-fill-target': '20480s'
},
'volume_nr': 0
}]
}],
'resource':
'beijing'
}]
fake = {}
fake['stdout'] = '''
[
{
"resource": "beijing",
"_this_host": {
"node-id": 1,
"volumes": [
{
"volume_nr": 0,
"device_minor": 5,
"disk": "/dev/vdb1",
"meta-disk": "internal",
"disk": {
"on-io-error": "pass_on"
}
}
]
},
"connections": [
{
"_peer_node_id": 2,
"path": {
"_this_host": "ipv4 192.168.10.102:7990",
"_remote_host": "ipv4 192.168.10.103:7990"
},
"net": {
"ping-timeout": "10",
"_name": "salt-node3"
},
"volumes": [
{
"volume_nr": 0,
"disk": {
"c-fill-target": "20480s"
}
}
]
}
]
}
]
'''
fake['stderr'] = ""
fake['retcode'] = 0
mock_cmd = MagicMock(return_value=fake)
with patch.dict(drbd.__salt__, {'cmd.run_all': mock_cmd}):
assert drbd.setup_show() == ret
mock_cmd.assert_called_once_with('drbdsetup show --json all')
# Test 2: Return code is not 0
ret = {
'name': 'all',
'result': False,
'comment': 'Error(10) happend when show resource via drbdsetup.'
}
fake = {'retcode': 10}
mock_cmd = MagicMock(return_value=fake)
with patch.dict(drbd.__salt__, {'cmd.run_all': mock_cmd}):
assert drbd.setup_show() == ret
mock_cmd.assert_called_once_with('drbdsetup show --json all')
# Test 3: Raise json ValueError
fake = {}
# Wrong Json format to raise ValueError
fake['stdout'] = '''[{'1': '2': '3'}]'''
fake['stderr'] = ""
fake['retcode'] = 0
mock_cmd = MagicMock(return_value=fake)
with patch.dict(drbd.__salt__, {'cmd.run_all': mock_cmd}):
self.assertRaises(exceptions.CommandExecutionError,
drbd.setup_show)
def run_checks(isdir=mock_t, strptime_format=None, test=False):
expected_ret = {
"name": fake_name,
"changes": {
"retained": [],
"deleted": [],
"ignored": []
},
"result": True,
"comment": "Name provided to file.retention must be a directory",
}
if strptime_format:
fake_file_list = sorted(fake_matching_file_list +
fake_no_match_file_list)
else:
fake_file_list = sorted(fake_matching_file_list)
mock_readdir = MagicMock(return_value=fake_file_list)
with patch.dict(filestate.__opts__, {"test": test}):
with patch.object(os.path, "isdir", isdir):
mock_readdir.reset_mock()
with patch.dict(filestate.__salt__,
{"file.readdir": mock_readdir}):
with patch.dict(filestate.__salt__,
{"file.lstat": mock_lstat}):
mock_remove.reset_mock()
with patch.dict(filestate.__salt__,
{"file.remove": mock_remove}):
if strptime_format:
actual_ret = filestate.retention_schedule(
fake_name,
fake_retain,
strptime_format=fake_strptime_format,
)
else:
actual_ret = filestate.retention_schedule(
fake_name, fake_retain)
if not isdir():
mock_readdir.assert_has_calls([])
expected_ret["result"] = False
else:
mock_readdir.assert_called_once_with(fake_name)
ignored_files = fake_no_match_file_list if strptime_format else []
retained_files = set(
generate_fake_files(maxfiles=fake_retain["most_recent"]))
junk_list = [
("first_of_hour", relativedelta(hours=1)),
("first_of_day", relativedelta(days=1)),
("first_of_week", relativedelta(weeks=1)),
("first_of_month", relativedelta(months=1)),
("first_of_year", relativedelta(years=1)),
]
for retainable, retain_interval in junk_list:
new_retains = set(
generate_fake_files(maxfiles=fake_retain[retainable],
every=retain_interval))
# if we generate less than the number of files expected,
# then the oldest file will also be retained
# (correctly, since its the first in it's category)
if (fake_retain[retainable] == "all"
or len(new_retains) < fake_retain[retainable]):
new_retains.add(fake_file_list[0])
retained_files |= new_retains
deleted_files = sorted(
list(
set(fake_file_list) - retained_files - set(ignored_files)),
reverse=True,
)
retained_files = sorted(list(retained_files), reverse=True)
expected_ret["changes"] = {
"retained": retained_files,
"deleted": deleted_files,
"ignored": ignored_files,
}
if test:
expected_ret["result"] = None
expected_ret[
"comment"] = "{} backups would have been removed from {}.\n" "".format(
len(deleted_files), fake_name)
else:
expected_ret[
"comment"] = "{} backups were removed from {}.\n" "".format(
len(deleted_files), fake_name)
mock_remove.assert_has_calls(
[call(os.path.join(fake_name, x)) for x in deleted_files],
any_order=True,
)
assert actual_ret == expected_ret
def test_enable(self):
"""
Test for Enable the named service to start at boot
"""
rc_update_mock = MagicMock(return_value=0)
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertTrue(gentoo_service.enable("name"))
rc_update_mock.assert_called_once_with("rc-update add name",
ignore_retcode=False,
python_shell=False)
rc_update_mock.reset_mock()
# move service from 'l1' to 'l2' runlevel
service_name = "name"
runlevels = ["l1"]
level_list_mock = MagicMock(
return_value=self.__services({service_name: runlevels}))
with patch.dict(gentoo_service.__salt__, {"cmd.run": level_list_mock}):
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertTrue(gentoo_service.enable("name", runlevels="l2"))
rc_update_mock.assert_has_calls([
call("rc-update delete name l1",
ignore_retcode=False,
python_shell=False),
call("rc-update add name l2",
ignore_retcode=False,
python_shell=False),
])
rc_update_mock.reset_mock()
# requested levels are the same as the current ones
with patch.dict(gentoo_service.__salt__, {"cmd.run": level_list_mock}):
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertTrue(gentoo_service.enable("name", runlevels="l1"))
self.assertTrue(rc_update_mock.call_count == 0)
rc_update_mock.reset_mock()
# same as above with the list instead of the string
with patch.dict(gentoo_service.__salt__, {"cmd.run": level_list_mock}):
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertTrue(gentoo_service.enable("name",
runlevels=["l1"]))
self.assertTrue(rc_update_mock.call_count == 0)
rc_update_mock.reset_mock()
# add service to 'l2' runlevel
with patch.dict(gentoo_service.__salt__, {"cmd.run": level_list_mock}):
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertTrue(
gentoo_service.enable("name", runlevels=["l2", "l1"]))
rc_update_mock.assert_called_once_with("rc-update add name l2",
ignore_retcode=False,
python_shell=False)
rc_update_mock.reset_mock()
# remove service from 'l1' runlevel
runlevels = ["l1", "l2"]
level_list_mock = MagicMock(
return_value=self.__services({service_name: runlevels}))
with patch.dict(gentoo_service.__salt__, {"cmd.run": level_list_mock}):
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertTrue(gentoo_service.enable("name",
runlevels=["l2"]))
rc_update_mock.assert_called_once_with("rc-update delete name l1",
ignore_retcode=False,
python_shell=False)
rc_update_mock.reset_mock()
# move service from 'l2' add to 'l3', leaving at l1
with patch.dict(gentoo_service.__salt__, {"cmd.run": level_list_mock}):
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertTrue(
gentoo_service.enable("name", runlevels=["l1", "l3"]))
rc_update_mock.assert_has_calls([
call("rc-update delete name l2",
ignore_retcode=False,
python_shell=False),
call("rc-update add name l3",
ignore_retcode=False,
python_shell=False),
])
rc_update_mock.reset_mock()
# remove from l1, l3, and add to l2, l4, and leave at l5
runlevels = ["l1", "l3", "l5"]
level_list_mock = MagicMock(
return_value=self.__services({service_name: runlevels}))
with patch.dict(gentoo_service.__salt__, {"cmd.run": level_list_mock}):
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertTrue(
gentoo_service.enable("name", runlevels=["l2", "l4",
"l5"]))
rc_update_mock.assert_has_calls([
call(
"rc-update delete name l1 l3",
ignore_retcode=False,
python_shell=False,
),
call("rc-update add name l2 l4",
ignore_retcode=False,
python_shell=False),
])
rc_update_mock.reset_mock()
# rc-update failed
rc_update_mock = MagicMock(return_value=1)
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertFalse(gentoo_service.enable("name"))
rc_update_mock.assert_called_once_with("rc-update add name",
ignore_retcode=False,
python_shell=False)
rc_update_mock.reset_mock()
# move service delete failed
runlevels = ["l1"]
level_list_mock = MagicMock(
return_value=self.__services({service_name: runlevels}))
with patch.dict(gentoo_service.__salt__, {"cmd.run": level_list_mock}):
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertFalse(gentoo_service.enable("name", runlevels="l2"))
rc_update_mock.assert_called_once_with("rc-update delete name l1",
ignore_retcode=False,
python_shell=False)
rc_update_mock.reset_mock()
# move service delete succeeds. add fails
rc_update_mock = MagicMock()
rc_update_mock.side_effect = [0, 1]
with patch.dict(gentoo_service.__salt__, {"cmd.run": level_list_mock}):
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertFalse(gentoo_service.enable("name", runlevels="l2"))
rc_update_mock.assert_has_calls([
call("rc-update delete name l1",
ignore_retcode=False,
python_shell=False),
call("rc-update add name l2",
ignore_retcode=False,
python_shell=False),
])
rc_update_mock.reset_mock()
def test_wipe(self):
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(disk.__salt__, {'cmd.run_all': mock}):
disk.wipe('/dev/sda')
mock.assert_called_once_with('wipefs -a /dev/sda',
python_shell=False)
class RemoveDiskgroup(TestCase):
"""Tests for salt.utils.vsan.remove_diskgroup"""
def setUp(self):
self.mock_si = MagicMock()
self.mock_task = MagicMock()
self.mock_remove_disk_mapping = MagicMock(return_value=self.mock_task)
self.mock_host_vsan_system = MagicMock(
RemoveDiskMapping_Task=self.mock_remove_disk_mapping)
self.mock_host_ref = MagicMock()
self.mock_cache_disk = MagicMock()
self.mock_diskgroup = MagicMock(ssd=self.mock_cache_disk)
self.mock_cap_disk1 = MagicMock()
self.mock_cap_disk2 = MagicMock()
self.mock_spec = MagicMock()
patches = (
(
"salt.utils.vmware.get_managed_object_name",
MagicMock(return_value="fake_hostname"),
),
(
"salt.utils.vsan.get_host_vsan_system",
MagicMock(return_value=self.mock_host_vsan_system),
),
(
"salt.utils.vsan.vim.HostMaintenanceSpec",
MagicMock(return_value=self.mock_spec),
),
("salt.utils.vsan.vim.VsanHostDecommissionMode", MagicMock()),
("salt.utils.vmware.wait_for_task", MagicMock()),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def test_get_hostname(self):
mock_get_managed_object_name = MagicMock(return_value="fake_hostname")
with patch("salt.utils.vmware.get_managed_object_name",
mock_get_managed_object_name):
vsan.remove_diskgroup(self.mock_si, self.mock_host_ref,
self.mock_diskgroup)
mock_get_managed_object_name.assert_called_once_with(
self.mock_host_ref)
def test_maintenance_mode_evacuate_all_data(self):
vsan.remove_diskgroup(self.mock_si, self.mock_host_ref,
self.mock_diskgroup)
vsan.remove_capacity_from_diskgroup(
self.mock_si,
self.mock_host_ref,
self.mock_diskgroup,
[self.mock_cap_disk1, self.mock_cap_disk2],
)
self.assertEqual(
self.mock_spec.vsanMode.objectAction,
vim.VsanHostDecommissionModeObjectAction.evacuateAllData,
)
def test_maintenance_mode_no_action(self):
vsan.remove_diskgroup(self.mock_si, self.mock_host_ref,
self.mock_diskgroup)
vsan.remove_capacity_from_diskgroup(
self.mock_si,
self.mock_host_ref,
self.mock_diskgroup,
[self.mock_cap_disk1, self.mock_cap_disk2],
data_evacuation=False,
)
self.assertEqual(
self.mock_spec.vsanMode.objectAction,
vim.VsanHostDecommissionModeObjectAction.noAction,
)
def test_remove_disk_mapping(self):
vsan.remove_diskgroup(self.mock_si, self.mock_host_ref,
self.mock_diskgroup)
vsan.remove_capacity_from_diskgroup(
self.mock_si,
self.mock_host_ref,
self.mock_diskgroup,
[self.mock_cap_disk1, self.mock_cap_disk2],
)
self.mock_remove_disk_mapping.assert_called_once_with(
mapping=[self.mock_diskgroup], maintenanceSpec=self.mock_spec)
def test_remove_disk_mapping_raise_no_permission(self):
vsan.remove_diskgroup(self.mock_si, self.mock_host_ref,
self.mock_diskgroup)
err = vim.fault.NoPermission()
err.privilegeId = "Fake privilege"
self.mock_host_vsan_system.RemoveDiskMapping_Task = MagicMock(
side_effect=err)
with self.assertRaises(VMwareApiError) as excinfo:
vsan.remove_diskgroup(self.mock_si, self.mock_host_ref,
self.mock_diskgroup)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: "
"Fake privilege",
)
def test_remove_disk_mapping_raise_vim_fault(self):
err = vim.fault.VimFault()
err.msg = "vim_fault"
self.mock_host_vsan_system.RemoveDiskMapping_Task = MagicMock(
side_effect=err)
with self.assertRaises(VMwareApiError) as excinfo:
vsan.remove_diskgroup(self.mock_si, self.mock_host_ref,
self.mock_diskgroup)
self.assertEqual(excinfo.exception.strerror, "vim_fault")
def test_remove_disk_mapping_raise_runtime_fault(self):
err = vmodl.RuntimeFault()
err.msg = "runtime_fault"
self.mock_host_vsan_system.RemoveDiskMapping_Task = MagicMock(
side_effect=err)
with self.assertRaises(VMwareRuntimeError) as excinfo:
vsan.remove_diskgroup(self.mock_si, self.mock_host_ref,
self.mock_diskgroup)
self.assertEqual(excinfo.exception.strerror, "runtime_fault")
def test_wait_for_tasks(self):
mock_wait_for_task = MagicMock()
with patch("salt.utils.vmware.wait_for_task", mock_wait_for_task):
vsan.remove_diskgroup(self.mock_si, self.mock_host_ref,
self.mock_diskgroup)
mock_wait_for_task.assert_called_once_with(self.mock_task,
"fake_hostname",
"remove_diskgroup")
def test_result(self):
res = vsan.remove_diskgroup(self.mock_si, self.mock_host_ref,
self.mock_diskgroup)
self.assertTrue(res)
def test_get_managed_object_name_call(self):
mock_get_managed_object_name = MagicMock()
with patch("salt.utils.vmware.get_managed_object_name",
mock_get_managed_object_name):
vsan.get_cluster_vsan_info(self.mock_cl_ref)
mock_get_managed_object_name.assert_called_once_with(self.mock_cl_ref)
class GetDvssTestCase(TestCase):
def setUp(self):
self.mock_si = MagicMock()
self.mock_dc_ref = MagicMock()
self.mock_traversal_spec = MagicMock()
self.mock_items = [{
'object': MagicMock(),
'name': 'fake_dvs1'
}, {
'object': MagicMock(),
'name': 'fake_dvs2'
}, {
'object': MagicMock(),
'name': 'fake_dvs3'
}]
self.mock_get_mors = MagicMock(return_value=self.mock_items)
patches = (
('salt.utils.vmware.get_managed_object_name', MagicMock()),
('salt.utils.vmware.get_mors_with_properties', self.mock_get_mors),
('salt.utils.vmware.get_service_instance_from_managed_object',
MagicMock(return_value=self.mock_si)),
('salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec',
MagicMock(return_value=self.mock_traversal_spec)))
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def tearDown(self):
for attr in ('mock_si', 'mock_dc_ref', 'mock_traversal_spec',
'mock_items', 'mock_get_mors'):
delattr(self, attr)
def test_get_managed_object_name_call(self):
mock_get_managed_object_name = MagicMock()
with patch('salt.utils.vmware.get_managed_object_name',
mock_get_managed_object_name):
vmware.get_dvss(self.mock_dc_ref)
mock_get_managed_object_name.assert_called_once_with(self.mock_dc_ref)
def test_traversal_spec(self):
mock_traversal_spec = MagicMock(return_value='traversal_spec')
with patch(
'salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec',
mock_traversal_spec):
vmware.get_dvss(self.mock_dc_ref)
mock_traversal_spec.assert_has_calls([
call(path='childEntity', skip=False, type=vim.Folder),
call(path='networkFolder',
skip=True,
type=vim.Datacenter,
selectSet=['traversal_spec'])
])
def test_get_mors_with_properties(self):
vmware.get_dvss(self.mock_dc_ref)
self.mock_get_mors.assert_called_once_with(
self.mock_si,
vim.DistributedVirtualSwitch,
container_ref=self.mock_dc_ref,
property_list=['name'],
traversal_spec=self.mock_traversal_spec)
def test_get_no_dvss(self):
ret = vmware.get_dvss(self.mock_dc_ref)
self.assertEqual(ret, [])
def test_get_all_dvss(self):
ret = vmware.get_dvss(self.mock_dc_ref, get_all_dvss=True)
self.assertEqual(ret, [i['object'] for i in self.mock_items])
def test_filtered_all_dvss(self):
ret = vmware.get_dvss(self.mock_dc_ref,
dvs_names=['fake_dvs1', 'fake_dvs3', 'no_dvs'])
self.assertEqual(
ret, [self.mock_items[0]['object'], self.mock_items[2]['object']])
class ReconfigureClusterVsanTestCase(TestCase):
"""Tests for salt.utils.vsan.reconfigure_cluster_vsan"""
def setUp(self):
self.mock_si = MagicMock()
self.mock_task = MagicMock()
self.mock_cl_reconf = MagicMock(return_value=self.mock_task)
self.mock_get_vsan_conf_sys = MagicMock(return_value=MagicMock(
VsanClusterReconfig=self.mock_cl_reconf))
self.mock_cl_ref = MagicMock()
self.mock_cl_vsan_spec = MagicMock()
patches = (
("salt.utils.vmware.get_managed_object_name", MagicMock()),
(
"salt.utils.vmware.get_service_instance_from_managed_object",
MagicMock(return_value=self.mock_si),
),
(
"salt.utils.vsan.get_vsan_cluster_config_system",
self.mock_get_vsan_conf_sys,
),
("salt.utils.vsan._wait_for_tasks", MagicMock()),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def tearDown(self):
for attr in (
"mock_si",
"mock_cl_reconf",
"mock_get_vsan_conf_sys",
"mock_cl_ref",
"mock_cl_vsan_spec",
"mock_task",
):
delattr(self, attr)
def test_get_cluster_name_call(self):
get_managed_object_name_mock = MagicMock()
with patch("salt.utils.vmware.get_managed_object_name",
get_managed_object_name_mock):
vsan.reconfigure_cluster_vsan(self.mock_cl_ref,
self.mock_cl_vsan_spec)
get_managed_object_name_mock.assert_called_once_with(self.mock_cl_ref)
def test_get_service_instance_call(self):
get_service_instance_from_managed_object_mock = MagicMock()
with patch(
"salt.utils.vmware.get_service_instance_from_managed_object",
get_service_instance_from_managed_object_mock,
):
vsan.reconfigure_cluster_vsan(self.mock_cl_ref,
self.mock_cl_vsan_spec)
get_service_instance_from_managed_object_mock.assert_called_once_with(
self.mock_cl_ref)
def test_get_vsan_cluster_config_system_call(self):
vsan.reconfigure_cluster_vsan(self.mock_cl_ref, self.mock_cl_vsan_spec)
self.mock_get_vsan_conf_sys.assert_called_once_with(self.mock_si)
def test_cluster_reconfig_call(self):
vsan.reconfigure_cluster_vsan(self.mock_cl_ref, self.mock_cl_vsan_spec)
self.mock_cl_reconf.assert_called_once_with(self.mock_cl_ref,
self.mock_cl_vsan_spec)
def test_cluster_reconfig_raises_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
with patch(
"salt.utils.vsan.get_vsan_cluster_config_system",
MagicMock(return_value=MagicMock(VsanClusterReconfig=MagicMock(
side_effect=exc))),
):
with self.assertRaises(VMwareApiError) as excinfo:
vsan.reconfigure_cluster_vsan(self.mock_cl_ref,
self.mock_cl_vsan_spec)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: "
"Fake privilege",
)
def test_cluster_reconfig_raises_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
with patch(
"salt.utils.vsan.get_vsan_cluster_config_system",
MagicMock(return_value=MagicMock(VsanClusterReconfig=MagicMock(
side_effect=exc))),
):
with self.assertRaises(VMwareApiError) as excinfo:
vsan.reconfigure_cluster_vsan(self.mock_cl_ref,
self.mock_cl_vsan_spec)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_cluster_reconfig_raises_vmodl_runtime_error(self):
exc = vmodl.RuntimeFault()
exc.msg = "VimRuntime msg"
with patch(
"salt.utils.vsan.get_vsan_cluster_config_system",
MagicMock(return_value=MagicMock(VsanClusterReconfig=MagicMock(
side_effect=exc))),
):
with self.assertRaises(VMwareRuntimeError) as excinfo:
vsan.reconfigure_cluster_vsan(self.mock_cl_ref,
self.mock_cl_vsan_spec)
self.assertEqual(excinfo.exception.strerror, "VimRuntime msg")
def test__wait_for_tasks_call(self):
mock_wait_for_tasks = MagicMock()
with patch("salt.utils.vsan._wait_for_tasks", mock_wait_for_tasks):
vsan.reconfigure_cluster_vsan(self.mock_cl_ref,
self.mock_cl_vsan_spec)
mock_wait_for_tasks.assert_called_once_with([self.mock_task],
self.mock_si)
class CreateDvsTestCase(TestCase):
def setUp(self):
self.mock_dc_ref = MagicMock()
self.mock_dvs_create_spec = MagicMock()
self.mock_task = MagicMock(spec=FakeTaskClass)
self.mock_netw_folder = \
MagicMock(CreateDVS_Task=MagicMock(
return_value=self.mock_task))
self.mock_wait_for_task = MagicMock()
patches = (('salt.utils.vmware.get_managed_object_name',
MagicMock(return_value='fake_dc')),
('salt.utils.vmware.get_network_folder',
MagicMock(return_value=self.mock_netw_folder)),
('salt.utils.vmware.wait_for_task',
self.mock_wait_for_task))
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def tearDown(self):
for attr in ('mock_dc_ref', 'mock_dvs_create_spec', 'mock_task',
'mock_netw_folder', 'mock_wait_for_task'):
delattr(self, attr)
def test_get_managed_object_name_call(self):
mock_get_managed_object_name = MagicMock()
with patch('salt.utils.vmware.get_managed_object_name',
mock_get_managed_object_name):
vmware.create_dvs(self.mock_dc_ref, 'fake_dvs')
mock_get_managed_object_name.assert_called_once_with(self.mock_dc_ref)
def test_no_dvs_create_spec(self):
mock_spec = MagicMock(configSpec=None)
mock_config_spec = MagicMock()
mock_dvs_create_spec = MagicMock(return_value=mock_spec)
mock_vmware_dvs_config_spec = \
MagicMock(return_value=mock_config_spec)
with patch('salt.utils.vmware.vim.DVSCreateSpec',
mock_dvs_create_spec):
with patch('salt.utils.vmware.vim.VMwareDVSConfigSpec',
mock_vmware_dvs_config_spec):
vmware.create_dvs(self.mock_dc_ref, 'fake_dvs')
mock_dvs_create_spec.assert_called_once_with()
mock_vmware_dvs_config_spec.assert_called_once_with()
self.assertEqual(mock_spec.configSpec, mock_config_spec)
self.assertEqual(mock_config_spec.name, 'fake_dvs')
self.mock_netw_folder.CreateDVS_Task.assert_called_once_with(mock_spec)
def test_get_network_folder(self):
mock_get_network_folder = MagicMock()
with patch('salt.utils.vmware.get_network_folder',
mock_get_network_folder):
vmware.create_dvs(self.mock_dc_ref, 'fake_dvs')
mock_get_network_folder.assert_called_once_with(self.mock_dc_ref)
def test_create_dvs_task_passed_in_spec(self):
vmware.create_dvs(self.mock_dc_ref,
'fake_dvs',
dvs_create_spec=self.mock_dvs_create_spec)
self.mock_netw_folder.CreateDVS_Task.assert_called_once_with(
self.mock_dvs_create_spec)
def test_create_dvs_task_raises_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = 'Fake privilege'
self.mock_netw_folder.CreateDVS_Task = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
vmware.create_dvs(self.mock_dc_ref,
'fake_dvs',
dvs_create_spec=self.mock_dvs_create_spec)
self.assertEqual(
excinfo.exception.strerror,
'Not enough permissions. Required privilege: '
'Fake privilege')
def test_create_dvs_task_raises_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = 'VimFault msg'
self.mock_netw_folder.CreateDVS_Task = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
vmware.create_dvs(self.mock_dc_ref,
'fake_dvs',
dvs_create_spec=self.mock_dvs_create_spec)
self.assertEqual(excinfo.exception.strerror, 'VimFault msg')
def test_create_dvs_task_raises_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = 'RuntimeFault msg'
self.mock_netw_folder.CreateDVS_Task = MagicMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
vmware.create_dvs(self.mock_dc_ref,
'fake_dvs',
dvs_create_spec=self.mock_dvs_create_spec)
self.assertEqual(excinfo.exception.strerror, 'RuntimeFault msg')
def test_wait_for_tasks(self):
vmware.create_dvs(self.mock_dc_ref,
'fake_dvs',
dvs_create_spec=self.mock_dvs_create_spec)
self.mock_wait_for_task.assert_called_once_with(
self.mock_task, 'fake_dvs',
'<class \'unit.utils.vmware.test_dvs.FakeTaskClass\'>')
def test_get_network_folder(self):
mock_get_network_folder = MagicMock()
with patch('salt.utils.vmware.get_network_folder',
mock_get_network_folder):
vmware.create_dvs(self.mock_dc_ref, 'fake_dvs')
mock_get_network_folder.assert_called_once_with(self.mock_dc_ref)
class GetNetworkFolderTestCase(TestCase):
def setUp(self):
self.mock_si = MagicMock()
self.mock_dc_ref = MagicMock()
self.mock_traversal_spec = MagicMock()
self.mock_entries = [{
'object': MagicMock(),
'name': 'fake_netw_folder'
}]
self.mock_get_mors = MagicMock(return_value=self.mock_entries)
patches = (
('salt.utils.vmware.get_managed_object_name',
MagicMock(return_value='fake_dc')),
('salt.utils.vmware.get_service_instance_from_managed_object',
MagicMock(return_value=self.mock_si)),
('salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec',
MagicMock(return_value=self.mock_traversal_spec)),
('salt.utils.vmware.get_mors_with_properties', self.mock_get_mors))
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def tearDown(self):
for attr in ('mock_si', 'mock_dc_ref', 'mock_traversal_spec',
'mock_entries', 'mock_get_mors'):
delattr(self, attr)
def test_get_managed_object_name_call(self):
mock_get_managed_object_name = MagicMock()
with patch('salt.utils.vmware.get_managed_object_name',
mock_get_managed_object_name):
vmware.get_network_folder(self.mock_dc_ref)
mock_get_managed_object_name.assert_called_once_with(self.mock_dc_ref)
def test_traversal_spec(self):
mock_traversal_spec = MagicMock(return_value='traversal_spec')
with patch(
'salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec',
mock_traversal_spec):
vmware.get_network_folder(self.mock_dc_ref)
mock_traversal_spec.assert_called_once_with(path='networkFolder',
skip=False,
type=vim.Datacenter)
def test_get_mors_with_properties(self):
vmware.get_network_folder(self.mock_dc_ref)
self.mock_get_mors.assert_called_once_with(
self.mock_si,
vim.Folder,
container_ref=self.mock_dc_ref,
property_list=['name'],
traversal_spec=self.mock_traversal_spec)
def test_get_no_network_folder(self):
with patch('salt.utils.vmware.get_mors_with_properties',
MagicMock(return_value=[])):
with self.assertRaises(VMwareObjectRetrievalError) as excinfo:
vmware.get_network_folder(self.mock_dc_ref)
self.assertEqual(
excinfo.exception.strerror,
'Network folder in datacenter \'fake_dc\' wasn\'t '
'retrieved')
def test_get_network_folder(self):
ret = vmware.get_network_folder(self.mock_dc_ref)
self.assertEqual(ret, self.mock_entries[0]['object'])
def test_gem(self):
mock = MagicMock(return_value={"retcode": 0, "stdout": ""})
with patch.dict(
gem.__salt__,
{
"rvm.is_installed": MagicMock(return_value=False),
"rbenv.is_installed": MagicMock(return_value=False),
"cmd.run_all": mock,
},
):
gem._gem(["install", "rails"])
mock.assert_called_once_with(["gem", "install", "rails"],
runas=None,
python_shell=False)
mock = MagicMock(return_value={"retcode": 0, "stdout": ""})
rvm_mock = MagicMock()
with patch.dict(
gem.__salt__,
{
"rvm.is_installed": rvm_mock,
"rbenv.is_installed": rvm_mock,
"cmd.run_all": mock,
},
):
gem._gem(["install", "rails"], gem_bin="/usr/local/bin/gem")
self.assertEqual(
False,
rvm_mock.called,
"Should never call rvm.is_installed if gem_bin provided",
)
mock.assert_called_once_with(
["/usr/local/bin/gem", "install", "rails"],
runas=None,
python_shell=False,
)
mock = MagicMock(return_value=None)
with patch.dict(
gem.__salt__,
{
"rvm.is_installed": MagicMock(return_value=True),
"rbenv.is_installed": MagicMock(return_value=False),
"rvm.do": mock,
},
):
gem._gem(["install", "rails"], ruby="1.9.3")
mock.assert_called_once_with("1.9.3", ["gem", "install", "rails"],
runas=None)
mock = MagicMock(return_value=None)
with patch.dict(
gem.__salt__,
{
"rvm.is_installed": MagicMock(return_value=False),
"rbenv.is_installed": MagicMock(return_value=True),
"rbenv.do": mock,
},
), patch("salt.utils.platform.is_windows", return_value=False):
gem._gem(["install", "rails"])
mock.assert_called_once_with(["gem", "install", "rails"],
runas=None)
def test_setup_status(self):
'''
Test if setup_status function work well
Test data is get from drbd-9.0.16/drbd-utils-9.6.0
'''
# Test 1: Return code is 0
ret = [{
'connections': [{
'ap-in-flight':
0,
'congested':
False,
'connection-state':
'Connected',
'name':
'salt-node3',
'peer-node-id':
2,
'peer-role':
'Secondary',
'peer_devices': [{
'has-online-verify-details': False,
'has-sync-details': False,
'out-of-sync': 0,
'peer-client': False,
'peer-disk-state': 'UpToDate',
'pending': 0,
'percent-in-sync': 100.0,
'received': 0,
'replication-state': 'Established',
'resync-suspended': 'no',
'sent': 0,
'unacked': 0,
'volume': 0
}],
'rs-in-flight':
0
}],
'devices': [{
'al-writes': 0,
'bm-writes': 0,
'client': False,
'disk-state': 'UpToDate',
'lower-pending': 0,
'minor': 5,
'quorum': True,
'read': 0,
'size': 307152,
'upper-pending': 0,
'volume': 0,
'written': 0
}],
'name':
'beijing',
'node-id':
1,
'role':
'Primary',
'suspended':
False,
'write-ordering':
'flush'
}]
fake = {}
fake['stdout'] = '''
[
{
"name": "beijing",
"node-id": 1,
"role": "Primary",
"suspended": false,
"write-ordering": "flush",
"devices": [
{
"volume": 0,
"minor": 5,
"disk-state": "UpToDate",
"client": false,
"quorum": true,
"size": 307152,
"read": 0,
"written": 0,
"al-writes": 0,
"bm-writes": 0,
"upper-pending": 0,
"lower-pending": 0
} ],
"connections": [
{
"peer-node-id": 2,
"name": "salt-node3",
"connection-state": "Connected",
"congested": false,
"peer-role": "Secondary",
"ap-in-flight": 0,
"rs-in-flight": 0,
"peer_devices": [
{
"volume": 0,
"replication-state": "Established",
"peer-disk-state": "UpToDate",
"peer-client": false,
"resync-suspended": "no",
"received": 0,
"sent": 0,
"out-of-sync": 0,
"pending": 0,
"unacked": 0,
"has-sync-details": false,
"has-online-verify-details": false,
"percent-in-sync": 100.00
} ]
} ]
}
]
'''
fake['stderr'] = ""
fake['retcode'] = 0
mock_cmd = MagicMock(return_value=fake)
with patch.dict(drbd.__salt__, {'cmd.run_all': mock_cmd}):
assert drbd.setup_status() == ret
mock_cmd.assert_called_once_with('drbdsetup status --json all')
# Test 2: Return code is not 0
ret = {
'name': 'all',
'result': False,
'comment': 'Error(10) happend when show resource via drbdsetup.'
}
fake = {'retcode': 10}
mock_cmd = MagicMock(return_value=fake)
with patch.dict(drbd.__salt__, {'cmd.run_all': mock_cmd}):
assert drbd.setup_status() == ret
mock_cmd.assert_called_once_with('drbdsetup status --json all')
# Test 3: Raise json ValueError
fake = {}
# Wrong Json format to raise ValueError
fake['stdout'] = '''[{'1': '2': '3'}]'''
fake['stderr'] = ""
fake['retcode'] = 0
mock_cmd = MagicMock(return_value=fake)
with patch.dict(drbd.__salt__, {'cmd.run_all': mock_cmd}):
self.assertRaises(exceptions.CommandExecutionError,
drbd.setup_status)
class LinuxAclTestCase(TestCase, LoaderModuleMockMixin):
def setup_loader_modules(self):
self.cmdrun = MagicMock()
self.addCleanup(delattr, self, 'cmdrun')
return {linux_acl: {'__salt__': {'cmd.run': self.cmdrun}}}
def setUp(self):
self.file = '/tmp/file'
self.quoted_file = '"/tmp/file"'
self.files = ['/tmp/file1', '/tmp/file2', '/tmp/file3 with whitespaces']
self.quoted_files = ['"{0}"'.format(f) for f in self.files]
self.u_acl = ['u', 'myuser', 'rwx']
self.user_acl = ['user', 'myuser', 'rwx']
self.user_acl_cmd = 'u:myuser:rwx'
self.g_acl = ['g', 'mygroup', 'rwx']
self.group_acl = ['group', 'mygroup', 'rwx']
self.group_acl_cmd = 'g:mygroup:rwx'
self.d_u_acl = ['d:u', 'myuser', 'rwx']
self.d_user_acl = ['d:user', 'myuser', 'rwx']
self.default_user_acl = ['d:user', 'myuser', 'rwx']
self.default_user_acl_cmd = 'd:u:myuser:rwx'
def tearDown(self):
for attrname in ('file', 'quoted_file', 'files', 'quoted_files',
'u_acl', 'user_acl', 'user_acl_cmd', 'g_acl',
'group_acl', 'group_acl_cmd', 'd_u_acl',
'd_user_acl', 'default_user_acl', 'default_user_acl_cmd'):
delattr(self, attrname)
# too easy to test (DRY)
def test_version(self):
pass
def test_getfacl_wo_args(self):
self.assertRaises(CommandExecutionError, linux_acl.getfacl)
def test_getfacl_w_single_arg(self):
linux_acl.getfacl(self.file)
self.cmdrun.assert_called_once_with('getfacl --absolute-names ' + self.quoted_file, python_shell=False)
def test_getfacl_w_multiple_args(self):
linux_acl.getfacl(*self.files)
self.cmdrun.assert_called_once_with('getfacl --absolute-names ' + ' '.join(self.quoted_files), python_shell=False)
def test_getfacl__recursive_w_multiple_args(self):
linux_acl.getfacl(*self.files, recursive=True)
self.cmdrun.assert_called_once_with('getfacl --absolute-names -R ' + ' '.join(self.quoted_files), python_shell=False)
def test_wipefacls_wo_args(self):
self.assertRaises(CommandExecutionError, linux_acl.wipefacls)
def test_wipefacls_w_single_arg(self):
linux_acl.wipefacls(self.file)
self.cmdrun.assert_called_once_with('setfacl -b ' + self.quoted_file, python_shell=False)
def test_wipefacls_w_multiple_args(self):
linux_acl.wipefacls(*self.files)
self.cmdrun.assert_called_once_with('setfacl -b ' + ' '.join(self.quoted_files), python_shell=False)
def test_wipefacls__recursive_w_multiple_args(self):
linux_acl.wipefacls(*self.files, recursive=True)
self.cmdrun.assert_called_once_with('setfacl -b -R ' + ' '.join(self.quoted_files), python_shell=False)
def test_modfacl_wo_args(self):
for acl in [self.u_acl, self.user_acl, self.g_acl, self.group_acl]:
self.assertRaises(CommandExecutionError, linux_acl.modfacl, *acl)
def test_modfacl__u_w_single_arg(self):
linux_acl.modfacl(*(self.u_acl + [self.file]))
self.cmdrun.assert_called_once_with('setfacl -m ' + ' '.join([self.user_acl_cmd, self.quoted_file]), python_shell=False, raise_err=False)
def test_modfacl__u_w_multiple_args(self):
linux_acl.modfacl(*(self.u_acl + self.files))
self.cmdrun.assert_called_once_with('setfacl -m ' + ' '.join([self.user_acl_cmd] + self.quoted_files), python_shell=False, raise_err=False)
def test_modfacl__user_w_single_arg(self):
linux_acl.modfacl(*(self.user_acl + [self.file]))
self.cmdrun.assert_called_once_with('setfacl -m ' + ' '.join([self.user_acl_cmd, self.quoted_file]), python_shell=False, raise_err=False)
def test_modfacl__user_w_multiple_args(self):
linux_acl.modfacl(*(self.user_acl + self.files))
self.cmdrun.assert_called_once_with('setfacl -m ' + ' '.join([self.user_acl_cmd] + self.quoted_files), python_shell=False, raise_err=False)
def test_modfacl__g_w_single_arg(self):
linux_acl.modfacl(*(self.g_acl + [self.file]))
self.cmdrun.assert_called_once_with('setfacl -m ' + ' '.join([self.group_acl_cmd, self.quoted_file]), python_shell=False, raise_err=False)
def test_modfacl__g_w_multiple_args(self):
linux_acl.modfacl(*(self.g_acl + self.files))
self.cmdrun.assert_called_once_with('setfacl -m ' + ' '.join([self.group_acl_cmd] + self.quoted_files), python_shell=False, raise_err=False)
def test_modfacl__group_w_single_arg(self):
linux_acl.modfacl(*(self.group_acl + [self.file]))
self.cmdrun.assert_called_once_with('setfacl -m ' + ' '.join([self.group_acl_cmd, self.quoted_file]), python_shell=False, raise_err=False)
def test_modfacl__group_w_multiple_args(self):
linux_acl.modfacl(*(self.group_acl + self.files))
self.cmdrun.assert_called_once_with('setfacl -m ' + ' '.join([self.group_acl_cmd] + self.quoted_files), python_shell=False, raise_err=False)
def test_modfacl__d_u_w_single_arg(self):
linux_acl.modfacl(*(self.d_u_acl + [self.file]))
self.cmdrun.assert_called_once_with('setfacl -m ' + ' '.join([self.default_user_acl_cmd, self.quoted_file]), python_shell=False, raise_err=False)
def test_modfacl__d_u_w_multiple_args(self):
linux_acl.modfacl(*(self.d_u_acl + self.files))
self.cmdrun.assert_called_once_with('setfacl -m ' + ' '.join([self.default_user_acl_cmd] + self.quoted_files), python_shell=False, raise_err=False)
def test_modfacl__d_user_w_single_arg(self):
linux_acl.modfacl(*(self.d_user_acl + [self.file]))
self.cmdrun.assert_called_once_with('setfacl -m ' + ' '.join([self.default_user_acl_cmd, self.quoted_file]), python_shell=False, raise_err=False)
def test_modfacl__d_user_w_multiple_args(self):
linux_acl.modfacl(*(self.d_user_acl + self.files))
self.cmdrun.assert_called_once_with('setfacl -m ' + ' '.join([self.default_user_acl_cmd] + self.quoted_files), python_shell=False, raise_err=False)
def test_modfacl__default_user_w_single_arg(self):
linux_acl.modfacl(*(self.default_user_acl + [self.file]))
self.cmdrun.assert_called_once_with('setfacl -m ' + ' '.join([self.default_user_acl_cmd, self.quoted_file]), python_shell=False, raise_err=False)
def test_modfacl__default_user_w_multiple_args(self):
linux_acl.modfacl(*(self.default_user_acl + self.files))
self.cmdrun.assert_called_once_with('setfacl -m ' + ' '.join([self.default_user_acl_cmd] + self.quoted_files), python_shell=False, raise_err=False)
def test_modfacl__recursive_w_multiple_args(self):
linux_acl.modfacl(*(self.user_acl + self.files), recursive=True)
self.cmdrun.assert_called_once_with('setfacl -R -m ' + ' '.join([self.user_acl_cmd] + self.quoted_files), python_shell=False, raise_err=False)
def test_modfacl_raise_err(self):
mock = MagicMock(side_effect=CommandExecutionError('Custom err'))
with patch.dict(linux_acl.__salt__, {'cmd.run': mock}):
with self.assertRaises(CommandExecutionError) as excinfo:
linux_acl.modfacl(*(self.user_acl + self.files), raise_err=True)
self.assertEqual(excinfo.exception.strerror, 'Custom err')
def test_delfacl_wo_args(self):
for acl in [self.u_acl, self.user_acl, self.g_acl, self.group_acl]:
self.assertRaises(CommandExecutionError, linux_acl.delfacl, *acl[:-1])
def test_delfacl__u_w_single_arg(self):
linux_acl.delfacl(*(self.u_acl[:-1] + [self.file]))
self.cmdrun.assert_called_once_with('setfacl -x ' + ' '.join([self.user_acl_cmd.rpartition(':')[0], self.quoted_file]), python_shell=False)
def test_delfacl__u_w_multiple_args(self):
linux_acl.delfacl(*(self.u_acl[:-1] + self.files))
self.cmdrun.assert_called_once_with('setfacl -x ' + ' '.join([self.user_acl_cmd.rpartition(':')[0]] + self.quoted_files), python_shell=False)
def test_delfacl__user_w_single_arg(self):
linux_acl.delfacl(*(self.user_acl[:-1] + [self.file]))
self.cmdrun.assert_called_once_with('setfacl -x ' + ' '.join([self.user_acl_cmd.rpartition(':')[0], self.quoted_file]), python_shell=False)
def test_delfacl__user_w_multiple_args(self):
linux_acl.delfacl(*(self.user_acl[:-1] + self.files))
self.cmdrun.assert_called_once_with('setfacl -x ' + ' '.join([self.user_acl_cmd.rpartition(':')[0]] + self.quoted_files), python_shell=False)
def test_delfacl__g_w_single_arg(self):
linux_acl.delfacl(*(self.g_acl[:-1] + [self.file]))
self.cmdrun.assert_called_once_with('setfacl -x ' + ' '.join([self.group_acl_cmd.rpartition(':')[0], self.quoted_file]), python_shell=False)
def test_delfacl__g_w_multiple_args(self):
linux_acl.delfacl(*(self.g_acl[:-1] + self.files))
self.cmdrun.assert_called_once_with('setfacl -x ' + ' '.join([self.group_acl_cmd.rpartition(':')[0]] + self.quoted_files), python_shell=False)
def test_delfacl__group_w_single_arg(self):
linux_acl.delfacl(*(self.group_acl[:-1] + [self.file]))
self.cmdrun.assert_called_once_with('setfacl -x ' + ' '.join([self.group_acl_cmd.rpartition(':')[0], self.quoted_file]), python_shell=False)
def test_delfacl__group_w_multiple_args(self):
linux_acl.delfacl(*(self.group_acl[:-1] + self.files))
self.cmdrun.assert_called_once_with('setfacl -x ' + ' '.join([self.group_acl_cmd.rpartition(':')[0]] + self.quoted_files), python_shell=False)
def test_delfacl__d_u_w_single_arg(self):
linux_acl.delfacl(*(self.d_u_acl[:-1] + [self.file]))
self.cmdrun.assert_called_once_with('setfacl -x ' + ' '.join([self.default_user_acl_cmd.rpartition(':')[0], self.quoted_file]), python_shell=False)
def test_delfacl__d_u_w_multiple_args(self):
linux_acl.delfacl(*(self.d_u_acl[:-1] + self.files))
self.cmdrun.assert_called_once_with('setfacl -x ' + ' '.join([self.default_user_acl_cmd.rpartition(':')[0]] + self.quoted_files), python_shell=False)
def test_delfacl__d_user_w_single_arg(self):
linux_acl.delfacl(*(self.d_user_acl[:-1] + [self.file]))
self.cmdrun.assert_called_once_with('setfacl -x ' + ' '.join([self.default_user_acl_cmd.rpartition(':')[0], self.quoted_file]), python_shell=False)
def test_delfacl__d_user_w_multiple_args(self):
linux_acl.delfacl(*(self.d_user_acl[:-1] + self.files))
self.cmdrun.assert_called_once_with('setfacl -x ' + ' '.join([self.default_user_acl_cmd.rpartition(':')[0]] + self.quoted_files), python_shell=False)
def test_delfacl__default_user_w_single_arg(self):
linux_acl.delfacl(*(self.default_user_acl[:-1] + [self.file]))
self.cmdrun.assert_called_once_with('setfacl -x ' + ' '.join([self.default_user_acl_cmd.rpartition(':')[0], self.quoted_file]), python_shell=False)
def test_delfacl__default_user_w_multiple_args(self):
linux_acl.delfacl(*(self.default_user_acl[:-1] + self.files))
self.cmdrun.assert_called_once_with('setfacl -x ' + ' '.join([self.default_user_acl_cmd.rpartition(':')[0]] + self.quoted_files), python_shell=False)
def test_delfacl__recursive_w_multiple_args(self):
linux_acl.delfacl(*(self.default_user_acl[:-1] + self.files), recursive=True)
self.cmdrun.assert_called_once_with('setfacl -R -x ' + ' '.join([self.default_user_acl_cmd.rpartition(':')[0]] + self.quoted_files), python_shell=False)
class GetDvportgroupsTestCase(TestCase):
def setUp(self):
self.mock_si = MagicMock()
self.mock_dc_ref = MagicMock(spec=vim.Datacenter)
self.mock_dvs_ref = MagicMock(spec=vim.DistributedVirtualSwitch)
self.mock_traversal_spec = MagicMock()
self.mock_items = [{
'object': MagicMock(),
'name': 'fake_pg1'
}, {
'object': MagicMock(),
'name': 'fake_pg2'
}, {
'object': MagicMock(),
'name': 'fake_pg3'
}]
self.mock_get_mors = MagicMock(return_value=self.mock_items)
patches = (
('salt.utils.vmware.get_managed_object_name', MagicMock()),
('salt.utils.vmware.get_mors_with_properties', self.mock_get_mors),
('salt.utils.vmware.get_service_instance_from_managed_object',
MagicMock(return_value=self.mock_si)),
('salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec',
MagicMock(return_value=self.mock_traversal_spec)))
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def tearDown(self):
for attr in ('mock_si', 'mock_dc_ref', 'mock_dvs_ref',
'mock_traversal_spec', 'mock_items', 'mock_get_mors'):
delattr(self, attr)
def test_unsupported_parrent(self):
with self.assertRaises(ArgumentValueError) as excinfo:
vmware.get_dvportgroups(MagicMock())
self.assertEqual(
excinfo.exception.strerror,
'Parent has to be either a datacenter, or a '
'distributed virtual switch')
def test_get_managed_object_name_call(self):
mock_get_managed_object_name = MagicMock()
with patch('salt.utils.vmware.get_managed_object_name',
mock_get_managed_object_name):
vmware.get_dvportgroups(self.mock_dc_ref)
mock_get_managed_object_name.assert_called_once_with(self.mock_dc_ref)
def test_traversal_spec_datacenter_parent(self):
mock_traversal_spec = MagicMock(return_value='traversal_spec')
with patch(
'salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec',
mock_traversal_spec):
vmware.get_dvportgroups(self.mock_dc_ref)
mock_traversal_spec.assert_has_calls([
call(path='childEntity', skip=False, type=vim.Folder),
call(path='networkFolder',
skip=True,
type=vim.Datacenter,
selectSet=['traversal_spec'])
])
def test_traversal_spec_dvs_parent(self):
mock_traversal_spec = MagicMock(return_value='traversal_spec')
with patch(
'salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec',
mock_traversal_spec):
vmware.get_dvportgroups(self.mock_dvs_ref)
mock_traversal_spec.assert_called_once_with(
path='portgroup', skip=False, type=vim.DistributedVirtualSwitch)
def test_get_mors_with_properties(self):
vmware.get_dvportgroups(self.mock_dvs_ref)
self.mock_get_mors.assert_called_once_with(
self.mock_si,
vim.DistributedVirtualPortgroup,
container_ref=self.mock_dvs_ref,
property_list=['name'],
traversal_spec=self.mock_traversal_spec)
def test_get_no_pgs(self):
ret = vmware.get_dvportgroups(self.mock_dvs_ref)
self.assertEqual(ret, [])
def test_get_all_pgs(self):
ret = vmware.get_dvportgroups(self.mock_dvs_ref,
get_all_portgroups=True)
self.assertEqual(ret, [i['object'] for i in self.mock_items])
def test_filtered_pgs(self):
ret = vmware.get_dvss(self.mock_dc_ref,
dvs_names=['fake_pg1', 'fake_pg3', 'no_pg'])
self.assertEqual(
ret, [self.mock_items[0]['object'], self.mock_items[2]['object']])
def test_disconnect(self):
mock_disconnect = MagicMock()
with patch('salt.utils.vmware.Disconnect', mock_disconnect):
salt.utils.vmware.disconnect(service_instance=self.mock_si)
mock_disconnect.assert_called_once_with(self.mock_si)
class GetUplinkDvportgroupTestCase(TestCase):
def setUp(self):
self.mock_si = MagicMock()
self.mock_dvs_ref = MagicMock(spec=vim.DistributedVirtualSwitch)
self.mock_traversal_spec = MagicMock()
self.mock_items = [{
'object': MagicMock(),
'tag': [MagicMock(key='fake_tag')]
}, {
'object': MagicMock(),
'tag': [MagicMock(key='SYSTEM/DVS.UPLINKPG')]
}]
self.mock_get_mors = MagicMock(return_value=self.mock_items)
patches = (
('salt.utils.vmware.get_managed_object_name',
MagicMock(return_value='fake_dvs')),
('salt.utils.vmware.get_mors_with_properties', self.mock_get_mors),
('salt.utils.vmware.get_service_instance_from_managed_object',
MagicMock(return_value=self.mock_si)),
('salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec',
MagicMock(return_value=self.mock_traversal_spec)))
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def tearDown(self):
for attr in ('mock_si', 'mock_dvs_ref', 'mock_traversal_spec',
'mock_items', 'mock_get_mors'):
delattr(self, attr)
def test_get_managed_object_name_call(self):
mock_get_managed_object_name = MagicMock()
with patch('salt.utils.vmware.get_managed_object_name',
mock_get_managed_object_name):
vmware.get_uplink_dvportgroup(self.mock_dvs_ref)
mock_get_managed_object_name.assert_called_once_with(self.mock_dvs_ref)
def test_traversal_spec(self):
mock_traversal_spec = MagicMock(return_value='traversal_spec')
with patch(
'salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec',
mock_traversal_spec):
vmware.get_uplink_dvportgroup(self.mock_dvs_ref)
mock_traversal_spec.assert_called_once_with(
path='portgroup', skip=False, type=vim.DistributedVirtualSwitch)
def test_get_mors_with_properties(self):
vmware.get_uplink_dvportgroup(self.mock_dvs_ref)
self.mock_get_mors.assert_called_once_with(
self.mock_si,
vim.DistributedVirtualPortgroup,
container_ref=self.mock_dvs_ref,
property_list=['tag'],
traversal_spec=self.mock_traversal_spec)
def test_get_no_uplink_pg(self):
with patch('salt.utils.vmware.get_mors_with_properties',
MagicMock(return_value=[])):
with self.assertRaises(VMwareObjectRetrievalError) as excinfo:
vmware.get_uplink_dvportgroup(self.mock_dvs_ref)
self.assertEqual(excinfo.exception.strerror,
'Uplink portgroup of DVS \'fake_dvs\' wasn\'t found')
def test_get_uplink_pg(self):
ret = vmware.get_uplink_dvportgroup(self.mock_dvs_ref)
self.assertEqual(ret, self.mock_items[1]['object'])
class AddCapacityToDiskGroupTestCase(TestCase):
"""Tests for salt.utils.vsan.add_capacity_to_diskgroup"""
def setUp(self):
self.mock_si = MagicMock()
self.mock_task = MagicMock()
self.mock_initialise_disk_mapping = MagicMock(
return_value=self.mock_task)
self.mock_vsan_disk_mgmt_system = MagicMock(
InitializeDiskMappings=self.mock_initialise_disk_mapping)
self.mock_host_ref = MagicMock()
self.mock_cache_disk = MagicMock()
self.mock_diskgroup = MagicMock(ssd=self.mock_cache_disk)
self.mock_cap_disk1 = MagicMock()
self.mock_cap_disk2 = MagicMock()
self.mock_spec = MagicMock()
patches = (
(
"salt.utils.vmware.get_managed_object_name",
MagicMock(return_value="fake_hostname"),
),
(
"salt.utils.vsan.vim.VimVsanHostDiskMappingCreationSpec",
MagicMock(return_value=self.mock_spec),
),
("salt.utils.vsan._wait_for_tasks", MagicMock()),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def test_get_hostname(self):
mock_get_managed_object_name = MagicMock(return_value="fake_hostname")
with patch("salt.utils.vmware.get_managed_object_name",
mock_get_managed_object_name):
vsan.add_capacity_to_diskgroup(
self.mock_si,
self.mock_vsan_disk_mgmt_system,
self.mock_host_ref,
self.mock_diskgroup,
[self.mock_cap_disk1, self.mock_cap_disk2],
)
mock_get_managed_object_name.assert_called_once_with(
self.mock_host_ref)
def test_vsan_spec_all_flash(self):
self.mock_cap_disk1.ssd = True
vsan.add_capacity_to_diskgroup(
self.mock_si,
self.mock_vsan_disk_mgmt_system,
self.mock_host_ref,
self.mock_diskgroup,
[self.mock_cap_disk1, self.mock_cap_disk2],
)
self.assertEqual(self.mock_spec.capacityDisks,
[self.mock_cap_disk1, self.mock_cap_disk2])
self.assertEqual(self.mock_spec.cacheDisks, [self.mock_cache_disk])
self.assertEqual(self.mock_spec.creationType, "allFlash")
self.assertEqual(self.mock_spec.host, self.mock_host_ref)
def test_vsan_spec_hybrid(self):
self.mock_cap_disk1.ssd = False
vsan.add_capacity_to_diskgroup(
self.mock_si,
self.mock_vsan_disk_mgmt_system,
self.mock_host_ref,
self.mock_diskgroup,
[self.mock_cap_disk1, self.mock_cap_disk2],
)
self.mock_cap_disk1.ssd = False
self.assertEqual(self.mock_spec.creationType, "hybrid")
def test_initialize_disk_mapping(self):
vsan.add_capacity_to_diskgroup(
self.mock_si,
self.mock_vsan_disk_mgmt_system,
self.mock_host_ref,
self.mock_diskgroup,
[self.mock_cap_disk1, self.mock_cap_disk2],
)
self.mock_initialise_disk_mapping.assert_called_once_with(
self.mock_spec)
def test_initialize_disk_mapping_raise_no_permission(self):
err = vim.fault.NoPermission()
err.privilegeId = "Fake privilege"
self.mock_vsan_disk_mgmt_system.InitializeDiskMappings = MagicMock(
side_effect=err)
with self.assertRaises(VMwareApiError) as excinfo:
vsan.add_capacity_to_diskgroup(
self.mock_si,
self.mock_vsan_disk_mgmt_system,
self.mock_host_ref,
self.mock_diskgroup,
[self.mock_cap_disk1, self.mock_cap_disk2],
)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: "
"Fake privilege",
)
def test_initialize_disk_mapping_raise_vim_fault(self):
err = vim.fault.VimFault()
err.msg = "vim_fault"
self.mock_vsan_disk_mgmt_system.InitializeDiskMappings = MagicMock(
side_effect=err)
with self.assertRaises(VMwareApiError) as excinfo:
vsan.add_capacity_to_diskgroup(
self.mock_si,
self.mock_vsan_disk_mgmt_system,
self.mock_host_ref,
self.mock_diskgroup,
[self.mock_cap_disk1, self.mock_cap_disk2],
)
self.assertEqual(excinfo.exception.strerror, "vim_fault")
def test_initialize_disk_mapping_raise_method_not_found(self):
err = vmodl.fault.MethodNotFound()
err.method = "fake_method"
self.mock_vsan_disk_mgmt_system.InitializeDiskMappings = MagicMock(
side_effect=err)
with self.assertRaises(VMwareRuntimeError) as excinfo:
vsan.add_capacity_to_diskgroup(
self.mock_si,
self.mock_vsan_disk_mgmt_system,
self.mock_host_ref,
self.mock_diskgroup,
[self.mock_cap_disk1, self.mock_cap_disk2],
)
self.assertEqual(excinfo.exception.strerror,
"Method 'fake_method' not found")
def test_initialize_disk_mapping_raise_runtime_fault(self):
err = vmodl.RuntimeFault()
err.msg = "runtime_fault"
self.mock_vsan_disk_mgmt_system.InitializeDiskMappings = MagicMock(
side_effect=err)
with self.assertRaises(VMwareRuntimeError) as excinfo:
vsan.add_capacity_to_diskgroup(
self.mock_si,
self.mock_vsan_disk_mgmt_system,
self.mock_host_ref,
self.mock_diskgroup,
[self.mock_cap_disk1, self.mock_cap_disk2],
)
self.assertEqual(excinfo.exception.strerror, "runtime_fault")
def test__wait_for_tasks(self):
mock___wait_for_tasks = MagicMock()
with patch("salt.utils.vsan._wait_for_tasks", mock___wait_for_tasks):
vsan.add_capacity_to_diskgroup(
self.mock_si,
self.mock_vsan_disk_mgmt_system,
self.mock_host_ref,
self.mock_diskgroup,
[self.mock_cap_disk1, self.mock_cap_disk2],
)
mock___wait_for_tasks.assert_called_once_with([self.mock_task],
self.mock_si)
def test_result(self):
res = vsan.add_capacity_to_diskgroup(
self.mock_si,
self.mock_vsan_disk_mgmt_system,
self.mock_host_ref,
self.mock_diskgroup,
[self.mock_cap_disk1, self.mock_cap_disk2],
)
self.assertTrue(res)
def test_get_managed_object_name_call(self):
mock_get_managed_object_name = MagicMock()
with patch('salt.utils.vmware.get_managed_object_name',
mock_get_managed_object_name):
vmware.get_dvss(self.mock_dc_ref)
mock_get_managed_object_name.assert_called_once_with(self.mock_dc_ref)
class GetVsanClusterConfigSystemTestCase(TestCase, LoaderModuleMockMixin):
"""Tests for salt.utils.vsan.get_vsan_cluster_config_system"""
def setup_loader_modules(self):
return {
vsan: {
"__virtual__": MagicMock(return_value="vsan"),
"sys": MagicMock(),
"ssl": MagicMock(),
}
}
def setUp(self):
self.mock_si = MagicMock()
self.mock_ret = MagicMock()
patches = ((
"salt.utils.vsan.vsanapiutils.GetVsanVcMos",
MagicMock(
return_value={"vsan-cluster-config-system": self.mock_ret}),
), )
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
type(vsan.sys).version_info = PropertyMock(return_value=(2, 7, 9))
self.mock_context = MagicMock()
self.mock_create_default_context = MagicMock(
return_value=self.mock_context)
vsan.ssl.create_default_context = self.mock_create_default_context
def tearDown(self):
for attr in (
"mock_si",
"mock_ret",
"mock_context",
"mock_create_default_context",
):
delattr(self, attr)
def test_ssl_default_context_loaded(self):
vsan.get_vsan_cluster_config_system(self.mock_si)
self.mock_create_default_context.assert_called_once_with()
self.assertFalse(self.mock_context.check_hostname)
self.assertEqual(self.mock_context.verify_mode, vsan.ssl.CERT_NONE)
def test_ssl_default_context_not_loaded(self):
type(vsan.sys).version_info = PropertyMock(return_value=(2, 7, 8))
vsan.get_vsan_cluster_config_system(self.mock_si)
self.assertEqual(self.mock_create_default_context.call_count, 0)
def test_GetVsanVcMos_call(self):
mock_get_vsan_vc_mos = MagicMock()
with patch("salt.utils.vsan.vsanapiutils.GetVsanVcMos",
mock_get_vsan_vc_mos):
vsan.get_vsan_cluster_config_system(self.mock_si)
mock_get_vsan_vc_mos.assert_called_once_with(self.mock_si._stub,
context=self.mock_context)
def test_return(self):
ret = vsan.get_vsan_cluster_config_system(self.mock_si)
self.assertEqual(ret, self.mock_ret)
class RemoveDvportgroupTestCase(TestCase):
def setUp(self):
self.mock_task = MagicMock(spec=FakeTaskClass)
self.mock_pg_ref = \
MagicMock(Destroy_Task=MagicMock(
return_value=self.mock_task))
self.mock_wait_for_task = MagicMock()
patches = (('salt.utils.vmware.get_managed_object_name',
MagicMock(return_value='fake_pg')),
('salt.utils.vmware.wait_for_task',
self.mock_wait_for_task))
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def tearDown(self):
for attr in ('mock_pg_ref', 'mock_task', 'mock_wait_for_task'):
delattr(self, attr)
def test_get_managed_object_name_call(self):
mock_get_managed_object_name = MagicMock()
with patch('salt.utils.vmware.get_managed_object_name',
mock_get_managed_object_name):
vmware.remove_dvportgroup(self.mock_pg_ref)
mock_get_managed_object_name.assert_called_once_with(self.mock_pg_ref)
def test_destroy_task(self):
vmware.remove_dvportgroup(self.mock_pg_ref)
self.mock_pg_ref.Destroy_Task.assert_called_once_with()
def test_destroy_task_raises_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = 'Fake privilege'
self.mock_pg_ref.Destroy_Task = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
vmware.remove_dvportgroup(self.mock_pg_ref)
self.assertEqual(
excinfo.exception.strerror,
'Not enough permissions. Required privilege: '
'Fake privilege')
def test_destroy_treconfigure_dvporgroup_task_raises_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = 'VimFault msg'
self.mock_pg_ref.Destroy_Task = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
vmware.remove_dvportgroup(self.mock_pg_ref)
self.assertEqual(excinfo.exception.strerror, 'VimFault msg')
def test_destroy_treconfigure_dvporgroup_task_raises_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = 'RuntimeFault msg'
self.mock_pg_ref.Destroy_Task = MagicMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
vmware.remove_dvportgroup(self.mock_pg_ref)
self.assertEqual(excinfo.exception.strerror, 'RuntimeFault msg')
def test_wait_for_tasks(self):
vmware.remove_dvportgroup(self.mock_pg_ref)
self.mock_wait_for_task.assert_called_once_with(
self.mock_task, 'fake_pg',
'<class \'unit.utils.vmware.test_dvs.FakeTaskClass\'>')
def test_get_vsan_cluster_config_system_call(self):
mock_get_vsan_cl_syst = MagicMock()
with patch("salt.utils.vsan.get_vsan_cluster_config_system",
mock_get_vsan_cl_syst):
vsan.get_cluster_vsan_info(self.mock_cl_ref)
mock_get_vsan_cl_syst.assert_called_once_with(self.mock_si)
def test_get_managed_object_name_call(self):
mock_get_managed_object_name = MagicMock()
with patch('salt.utils.vmware.get_managed_object_name',
mock_get_managed_object_name):
vmware.remove_dvportgroup(self.mock_pg_ref)
mock_get_managed_object_name.assert_called_once_with(self.mock_pg_ref)
def test_disable(self):
"""
Test for Disable the named service to start at boot
"""
rc_update_mock = MagicMock(return_value=0)
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertTrue(gentoo_service.disable("name"))
rc_update_mock.assert_called_once_with("rc-update delete name",
ignore_retcode=False,
python_shell=False)
rc_update_mock.reset_mock()
# disable service
service_name = "name"
runlevels = ["l1"]
level_list_mock = MagicMock(
return_value=self.__services({service_name: runlevels}))
with patch.dict(gentoo_service.__salt__, {"cmd.run": level_list_mock}):
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertTrue(gentoo_service.disable("name", runlevels="l1"))
rc_update_mock.assert_called_once_with("rc-update delete name l1",
ignore_retcode=False,
python_shell=False)
rc_update_mock.reset_mock()
# same as above with list
runlevels = ["l1"]
level_list_mock = MagicMock(
return_value=self.__services({service_name: runlevels}))
with patch.dict(gentoo_service.__salt__, {"cmd.run": level_list_mock}):
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertTrue(
gentoo_service.disable("name", runlevels=["l1"]))
rc_update_mock.assert_called_once_with("rc-update delete name l1",
ignore_retcode=False,
python_shell=False)
rc_update_mock.reset_mock()
# remove from 'l1', and leave at 'l2'
runlevels = ["l1", "l2"]
level_list_mock = MagicMock(
return_value=self.__services({service_name: runlevels}))
with patch.dict(gentoo_service.__salt__, {"cmd.run": level_list_mock}):
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertTrue(
gentoo_service.disable("name", runlevels=["l1"]))
rc_update_mock.assert_called_once_with("rc-update delete name l1",
ignore_retcode=False,
python_shell=False)
rc_update_mock.reset_mock()
# remove from non-enabled level
runlevels = ["l2"]
level_list_mock = MagicMock(
return_value=self.__services({service_name: runlevels}))
with patch.dict(gentoo_service.__salt__, {"cmd.run": level_list_mock}):
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertTrue(
gentoo_service.disable("name", runlevels=["l1"]))
self.assertTrue(rc_update_mock.call_count == 0)
rc_update_mock.reset_mock()
# remove from 'l1' and 'l3', leave at 'l2'
runlevels = ["l1", "l2", "l3"]
level_list_mock = MagicMock(
return_value=self.__services({service_name: runlevels}))
with patch.dict(gentoo_service.__salt__, {"cmd.run": level_list_mock}):
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertTrue(
gentoo_service.disable("name", runlevels=["l1", "l3"]))
rc_update_mock.assert_called_once_with("rc-update delete name l1 l3",
ignore_retcode=False,
python_shell=False)
rc_update_mock.reset_mock()
# rc-update failed
rc_update_mock = MagicMock(return_value=1)
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertFalse(gentoo_service.disable("name"))
rc_update_mock.assert_called_once_with("rc-update delete name",
ignore_retcode=False,
python_shell=False)
rc_update_mock.reset_mock()
# move service delete failed
runlevels = ["l1"]
level_list_mock = MagicMock(
return_value=self.__services({service_name: runlevels}))
with patch.dict(gentoo_service.__salt__, {"cmd.run": level_list_mock}):
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertFalse(gentoo_service.disable("name",
runlevels="l1"))
rc_update_mock.assert_called_once_with("rc-update delete name l1",
ignore_retcode=False,
python_shell=False)
rc_update_mock.reset_mock()
# move service delete succeeds. add fails
runlevels = ["l1", "l2", "l3"]
level_list_mock = MagicMock(
return_value=self.__services({service_name: runlevels}))
with patch.dict(gentoo_service.__salt__, {"cmd.run": level_list_mock}):
with patch.dict(gentoo_service.__salt__,
{"cmd.retcode": rc_update_mock}):
self.assertFalse(
gentoo_service.disable("name", runlevels=["l1", "l3"]))
rc_update_mock.assert_called_once_with("rc-update delete name l1 l3",
ignore_retcode=False,
python_shell=False)
rc_update_mock.reset_mock()
def test_sls_build_dryrun(self, *args):
'''
test build sls image in dryrun mode.
'''
docker_start_mock = MagicMock(return_value={})
docker_create_mock = MagicMock(return_value={
'Id': 'ID',
'Name': 'NAME'
})
docker_stop_mock = MagicMock(return_value={
'state': {
'old': 'running',
'new': 'stopped'
},
'result': True
})
docker_rm_mock = MagicMock(return_value={})
docker_sls_mock = MagicMock(
return_value={
"file_|-/etc/test.sh_|-/etc/test.sh_|-managed": {
"comment": "File /etc/test.sh is in the correct state",
"name": "/etc/test.sh",
"start_time": "07:04:26.834792",
"result": True,
"duration": 13.492,
"__run_num__": 0,
"changes": {}
},
"test_|-always-passes_|-foo_|-succeed_without_changes": {
"comment": "Success!",
"name": "foo",
"start_time": "07:04:26.848915",
"result": True,
"duration": 0.363,
"__run_num__": 1,
"changes": {}
}
})
ret = None
with patch.object(docker_mod, 'start', docker_start_mock):
with patch.object(docker_mod, 'create', docker_create_mock):
with patch.object(docker_mod, 'stop', docker_stop_mock):
with patch.object(docker_mod, 'rm_', docker_rm_mock):
with patch.object(docker_mod, 'sls', docker_sls_mock):
ret = docker_mod.sls_build('foo',
mods='foo',
dryrun=True)
docker_create_mock.assert_called_once_with(cmd='sleep infinity',
image='opensuse/python',
interactive=True,
tty=True)
docker_start_mock.assert_called_once_with('ID')
docker_sls_mock.assert_called_once_with('ID', 'foo', 'base')
docker_stop_mock.assert_called_once_with('ID')
docker_rm_mock.assert_called_once_with('ID')
self.assertEqual(
{
"file_|-/etc/test.sh_|-/etc/test.sh_|-managed": {
"comment": "File /etc/test.sh is in the correct state",
"name": "/etc/test.sh",
"start_time": "07:04:26.834792",
"result": True,
"duration": 13.492,
"__run_num__": 0,
"changes": {}
},
"test_|-always-passes_|-foo_|-succeed_without_changes": {
"comment": "Success!",
"name": "foo",
"start_time": "07:04:26.848915",
"result": True,
"duration": 0.363,
"__run_num__": 1,
"changes": {}
}
}, ret)
def no_test_loaddata(self):
mock = MagicMock()
with patch.dict(django.__salt__, {'cmd.run': mock}):
django.loaddata('settings.py', 'app1,app2')
mock.assert_called_once_with(
'django-admin.py loaddata --settings=settings.py app1 app2', )
def test_install_with_multiple_find_links(self):
find_links = [
'http://g.pypi.python.org',
'http://c.pypi.python.org',
'http://pypi.crate.io'
]
pkg = 'pep8'
expected = ['pip', 'install']
for item in find_links:
expected.extend(['--find-links', item])
expected.append(pkg)
# Passing mirrors as a list
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
pip.install(pkg, find_links=find_links)
mock.assert_called_once_with(
expected,
saltenv='base',
runas=None,
use_vt=False,
python_shell=False,
)
# Passing mirrors as a comma separated list
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
pip.install(pkg, find_links=','.join(find_links))
mock.assert_called_once_with(
expected,
saltenv='base',
runas=None,
use_vt=False,
python_shell=False,
)
# As single string (just use the first element from find_links)
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
pip.install(pkg, find_links=find_links[0])
mock.assert_called_once_with(
['pip', 'install', '--find-links', find_links[0], pkg],
saltenv='base',
runas=None,
use_vt=False,
python_shell=False,
)
# Invalid proto raises exception
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
self.assertRaises(
CommandExecutionError,
pip.install,
'\'' + pkg + '\'',
find_links='sftp://pypi.crate.io'
)
# Valid protos work?
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
pip.install(pkg, find_links=find_links)
mock.assert_called_once_with(
expected,
saltenv='base',
runas=None,
use_vt=False,
python_shell=False,
)
