saltstack/salt
1
0
Fork 0
mirror of https://github.com/saltstack/salt.git synced 2025-04-17 10:10:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4
salt/tests/unit/utils/test_vmware.py
Megan Wilhite 46cd3263f9 Validate vmware module defaults to verifying SSL
2021-01-22 14:32:16 -07:00

5122 lines
199 KiB
Python
Raw Blame History

"""
:codeauthor: Alexandru Bleotu <alexandru.bleotu@morganstanley.com>
Tests for cluster related functions in salt.utils.vmware
"""
import base64
import logging
import ssl
import salt.utils.vmware
from salt.exceptions import (
ArgumentValueError,
CommandExecutionError,
VMwareApiError,
VMwareConnectionError,
VMwareObjectRetrievalError,
VMwareRuntimeError,
VMwareSystemError,
)
from tests.support.mixins import LoaderModuleMockMixin
from tests.support.mock import MagicMock, PropertyMock, call, patch
from tests.support.runtests import RUNTIME_VARS
from tests.support.unit import TestCase, skipIf
try:
from pyVmomi import vim, vmodl # pylint: disable=no-name-in-module
HAS_PYVMOMI = True
except ImportError:
HAS_PYVMOMI = False
try:
import gssapi
HAS_GSSAPI = True
except ImportError:
HAS_GSSAPI = False
log = logging.getLogger(__name__)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetClusterTestCase(TestCase):
"""
Tests for salt.utils.vmware.get_cluster
"""
def setUp(self):
patches = (
("salt.utils.vmware.get_managed_object_name", MagicMock()),
("salt.utils.vmware.get_service_instance_from_managed_object", MagicMock()),
(
"salt.utils.vmware.get_mors_with_properties",
MagicMock(
return_value=[{"name": "fake_cluster", "object": MagicMock()}]
),
),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
self.mock_si = MagicMock()
self.mock_dc = MagicMock()
self.mock_cluster1 = MagicMock()
self.mock_cluster2 = MagicMock()
self.mock_entries = [
{"name": "fake_cluster1", "object": self.mock_cluster1},
{"name": "fake_cluster2", "object": self.mock_cluster2},
]
for attr in (
"mock_si",
"mock_dc",
"mock_cluster1",
"mock_cluster2",
"mock_entries",
):
self.addCleanup(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
):
salt.utils.vmware.get_cluster(self.mock_dc, "fake_cluster")
mock_get_managed_object_name.assert_called_once_with(self.mock_dc)
def test_get_service_instance_from_managed_object(self):
mock_dc_name = MagicMock()
mock_get_service_instance_from_managed_object = MagicMock()
with patch(
"salt.utils.vmware.get_managed_object_name",
MagicMock(return_value=mock_dc_name),
):
with patch(
"salt.utils.vmware.get_service_instance_from_managed_object",
mock_get_service_instance_from_managed_object,
):
salt.utils.vmware.get_cluster(self.mock_dc, "fake_cluster")
mock_get_service_instance_from_managed_object.assert_called_once_with(
self.mock_dc, name=mock_dc_name
)
def test_traversal_spec_init(self):
mock_dc_name = MagicMock()
mock_traversal_spec = MagicMock()
mock_traversal_spec_ini = MagicMock(return_value=mock_traversal_spec)
mock_get_service_instance_from_managed_object = MagicMock()
patch_traversal_spec_str = (
"salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec"
)
with patch(patch_traversal_spec_str, mock_traversal_spec_ini):
salt.utils.vmware.get_cluster(self.mock_dc, "fake_cluster")
mock_traversal_spec_ini.assert_has_calls(
[
call(path="childEntity", skip=False, type=vim.Folder),
call(
path="hostFolder",
skip=True,
type=vim.Datacenter,
selectSet=[mock_traversal_spec],
),
]
)
def test_get_mors_with_properties_call(self):
mock_get_mors_with_properties = MagicMock(
return_value=[{"name": "fake_cluster", "object": MagicMock()}]
)
mock_traversal_spec = MagicMock()
patch_traversal_spec_str = (
"salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec"
)
with patch(
"salt.utils.vmware.get_service_instance_from_managed_object",
MagicMock(return_value=self.mock_si),
):
with patch(
"salt.utils.vmware.get_mors_with_properties",
mock_get_mors_with_properties,
):
with patch(
patch_traversal_spec_str,
MagicMock(return_value=mock_traversal_spec),
):
salt.utils.vmware.get_cluster(self.mock_dc, "fake_cluster")
mock_get_mors_with_properties.assert_called_once_with(
self.mock_si,
vim.ClusterComputeResource,
container_ref=self.mock_dc,
property_list=["name"],
traversal_spec=mock_traversal_spec,
)
def test_get_mors_with_properties_returns_empty_array(self):
with patch(
"salt.utils.vmware.get_managed_object_name",
MagicMock(return_value="fake_dc"),
):
with patch(
"salt.utils.vmware.get_mors_with_properties", MagicMock(return_value=[])
):
with self.assertRaises(VMwareObjectRetrievalError) as excinfo:
salt.utils.vmware.get_cluster(self.mock_dc, "fake_cluster")
self.assertEqual(
excinfo.exception.strerror,
"Cluster 'fake_cluster' was not found in " "datacenter 'fake_dc'",
)
def test_cluster_not_found(self):
with patch(
"salt.utils.vmware.get_managed_object_name",
MagicMock(return_value="fake_dc"),
):
with patch(
"salt.utils.vmware.get_mors_with_properties",
MagicMock(return_value=self.mock_entries),
):
with self.assertRaises(VMwareObjectRetrievalError) as excinfo:
salt.utils.vmware.get_cluster(self.mock_dc, "fake_cluster")
self.assertEqual(
excinfo.exception.strerror,
"Cluster 'fake_cluster' was not found in " "datacenter 'fake_dc'",
)
def test_cluster_found(self):
with patch(
"salt.utils.vmware.get_managed_object_name",
MagicMock(return_value="fake_dc"),
):
with patch(
"salt.utils.vmware.get_mors_with_properties",
MagicMock(return_value=self.mock_entries),
):
res = salt.utils.vmware.get_cluster(self.mock_dc, "fake_cluster2")
self.assertEqual(res, self.mock_cluster2)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class CreateClusterTestCase(TestCase):
"""
Tests for salt.utils.vmware.create_cluster
"""
def setUp(self):
patches = (("salt.utils.vmware.get_managed_object_name", MagicMock()),)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
self.mock_create_cluster_ex = MagicMock()
self.mock_dc = MagicMock(
hostFolder=MagicMock(CreateClusterEx=self.mock_create_cluster_ex)
)
self.mock_cluster_spec = MagicMock()
for attr in ("mock_create_cluster_ex", "mock_dc", "mock_cluster_spec"):
self.addCleanup(delattr, self, attr)
def test_get_managed_object_name(self):
mock_get_managed_object_name = MagicMock()
with patch(
"salt.utils.vmware.get_managed_object_name", mock_get_managed_object_name
):
salt.utils.vmware.create_cluster(
self.mock_dc, "fake_cluster", self.mock_cluster_spec
)
mock_get_managed_object_name.assert_called_once_with(self.mock_dc)
def test_create_cluster_call(self):
salt.utils.vmware.create_cluster(
self.mock_dc, "fake_cluster", self.mock_cluster_spec
)
self.mock_create_cluster_ex.assert_called_once_with(
"fake_cluster", self.mock_cluster_spec
)
def test_create_cluster_raise_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
self.mock_dc.hostFolder.CreateClusterEx = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.create_cluster(
self.mock_dc, "fake_cluster", self.mock_cluster_spec
)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_create_cluster_raise_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
self.mock_dc.hostFolder.CreateClusterEx = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.create_cluster(
self.mock_dc, "fake_cluster", self.mock_cluster_spec
)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_create_cluster_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
self.mock_dc.hostFolder.CreateClusterEx = MagicMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.create_cluster(
self.mock_dc, "fake_cluster", self.mock_cluster_spec
)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class UpdateClusterTestCase(TestCase):
"""
Tests for salt.utils.vmware.update_cluster
"""
def setUp(self):
patches = (
("salt.utils.vmware.get_managed_object_name", MagicMock()),
("salt.utils.vmware.wait_for_task", MagicMock()),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
self.mock_task = MagicMock()
self.mock_reconfigure_compute_resource_task = MagicMock(
return_value=self.mock_task
)
self.mock_cluster = MagicMock(
ReconfigureComputeResource_Task=self.mock_reconfigure_compute_resource_task
)
self.mock_cluster_spec = MagicMock()
for attr in (
"mock_task",
"mock_reconfigure_compute_resource_task",
"mock_cluster",
"mock_cluster_spec",
):
self.addCleanup(delattr, self, attr)
def test_get_managed_object_name(self):
mock_get_managed_object_name = MagicMock()
with patch(
"salt.utils.vmware.get_managed_object_name", mock_get_managed_object_name
):
salt.utils.vmware.update_cluster(self.mock_cluster, self.mock_cluster_spec)
mock_get_managed_object_name.assert_called_once_with(self.mock_cluster)
def test_reconfigure_compute_resource_task_call(self):
salt.utils.vmware.update_cluster(self.mock_cluster, self.mock_cluster_spec)
self.mock_reconfigure_compute_resource_task.assert_called_once_with(
self.mock_cluster_spec, modify=True
)
def test_reconfigure_compute_resource_raise_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
self.mock_cluster.ReconfigureComputeResource_Task = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.update_cluster(self.mock_cluster, self.mock_cluster_spec)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_reconfigure_compute_resource_raise_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
self.mock_cluster.ReconfigureComputeResource_Task = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.update_cluster(self.mock_cluster, self.mock_cluster_spec)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_reconfigure_compute_resource_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
self.mock_cluster.ReconfigureComputeResource_Task = MagicMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.update_cluster(self.mock_cluster, self.mock_cluster_spec)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_wait_for_task_call(self):
mock_wait_for_task = MagicMock()
with patch(
"salt.utils.vmware.get_managed_object_name",
MagicMock(return_value="fake_cluster"),
):
with patch("salt.utils.vmware.wait_for_task", mock_wait_for_task):
salt.utils.vmware.update_cluster(
self.mock_cluster, self.mock_cluster_spec
)
mock_wait_for_task.assert_called_once_with(
self.mock_task, "fake_cluster", "ClusterUpdateTask"
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class WaitForTaskTestCase(TestCase):
"""
Tests for salt.utils.vmware.wait_for_task
"""
def setUp(self):
patches = (
("salt.utils.vmware.time.time", MagicMock(return_value=1)),
("salt.utils.vmware.time.sleep", MagicMock(return_value=None)),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def test_first_task_info_raise_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
mock_task = MagicMock()
type(mock_task).info = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.wait_for_task(
mock_task, "fake_instance_name", "task_type"
)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_first_task_info_raise_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
mock_task = MagicMock()
type(mock_task).info = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.wait_for_task(
mock_task, "fake_instance_name", "task_type"
)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_first_task_info_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
mock_task = MagicMock()
type(mock_task).info = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.wait_for_task(
mock_task, "fake_instance_name", "task_type"
)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_inner_loop_task_info_raise_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
mock_task = MagicMock()
mock_info1 = MagicMock()
type(mock_task).info = PropertyMock(side_effect=[mock_info1, exc])
type(mock_info1).state = PropertyMock(side_effect=["running", "bad"])
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.wait_for_task(
mock_task, "fake_instance_name", "task_type"
)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_inner_loop_task_info_raise_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
mock_task = MagicMock()
mock_info1 = MagicMock()
type(mock_task).info = PropertyMock(side_effect=[mock_info1, exc])
type(mock_info1).state = PropertyMock(side_effect=["running", "bad"])
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.wait_for_task(
mock_task, "fake_instance_name", "task_type"
)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_inner_loop_task_info_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
mock_task = MagicMock()
mock_info1 = MagicMock()
type(mock_task).info = PropertyMock(side_effect=[mock_info1, exc])
type(mock_info1).state = PropertyMock(side_effect=["running", "bad"])
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.wait_for_task(
mock_task, "fake_instance_name", "task_type"
)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_info_state_running(self):
# The 'bad' values are invalid in the while loop
mock_task = MagicMock()
prop_mock_state = PropertyMock(side_effect=["running", "bad", "bad", "success"])
prop_mock_result = PropertyMock()
type(mock_task.info).state = prop_mock_state
type(mock_task.info).result = prop_mock_result
salt.utils.vmware.wait_for_task(mock_task, "fake_instance_name", "task_type")
self.assertEqual(prop_mock_state.call_count, 4)
self.assertEqual(prop_mock_result.call_count, 1)
def test_info_state_running_continues_loop(self):
mock_task = MagicMock()
# The 'fake' values are required to match all the lookups and end the
# loop
prop_mock_state = PropertyMock(
side_effect=["running", "fake", "fake", "success"]
)
prop_mock_result = PropertyMock()
type(mock_task.info).state = prop_mock_state
type(mock_task.info).result = prop_mock_result
salt.utils.vmware.wait_for_task(mock_task, "fake_instance_name", "task_type")
self.assertEqual(prop_mock_state.call_count, 4)
self.assertEqual(prop_mock_result.call_count, 1)
def test_info_state_queued_continues_loop(self):
mock_task = MagicMock()
# The 'fake' values are required to match all the lookups and end the
# loop
prop_mock_state = PropertyMock(
side_effect=["fake", "queued", "fake", "fake", "success"]
)
prop_mock_result = PropertyMock()
type(mock_task.info).state = prop_mock_state
type(mock_task.info).result = prop_mock_result
salt.utils.vmware.wait_for_task(mock_task, "fake_instance_name", "task_type")
self.assertEqual(prop_mock_state.call_count, 5)
self.assertEqual(prop_mock_result.call_count, 1)
def test_info_state_success(self):
mock_task = MagicMock()
prop_mock_state = PropertyMock(return_value="success")
prop_mock_result = PropertyMock()
type(mock_task.info).state = prop_mock_state
type(mock_task.info).result = prop_mock_result
salt.utils.vmware.wait_for_task(mock_task, "fake_instance_name", "task_type")
self.assertEqual(prop_mock_state.call_count, 3)
self.assertEqual(prop_mock_result.call_count, 1)
def test_info_error_exception(self):
mock_task = MagicMock()
prop_mock_state = PropertyMock(return_value="error")
prop_mock_error = PropertyMock(side_effect=Exception("error exc"))
type(mock_task.info).state = prop_mock_state
type(mock_task.info).error = prop_mock_error
with self.assertRaises(Exception) as excinfo:
salt.utils.vmware.wait_for_task(
mock_task, "fake_instance_name", "task_type"
)
self.assertEqual(str(excinfo.exception), "error exc")
def test_info_error_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
mock_task = MagicMock()
prop_mock_state = PropertyMock(return_value="error")
prop_mock_error = PropertyMock(side_effect=exc)
type(mock_task.info).state = prop_mock_state
type(mock_task.info).error = prop_mock_error
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.wait_for_task(
mock_task, "fake_instance_name", "task_type"
)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_info_error_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
mock_task = MagicMock()
prop_mock_state = PropertyMock(return_value="error")
prop_mock_error = PropertyMock(side_effect=exc)
type(mock_task.info).state = prop_mock_state
type(mock_task.info).error = prop_mock_error
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.wait_for_task(
mock_task, "fake_instance_name", "task_type"
)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_info_error_system_fault(self):
exc = vmodl.fault.SystemError()
exc.msg = "SystemError msg"
mock_task = MagicMock()
prop_mock_state = PropertyMock(return_value="error")
prop_mock_error = PropertyMock(side_effect=exc)
type(mock_task.info).state = prop_mock_state
type(mock_task.info).error = prop_mock_error
with self.assertRaises(VMwareSystemError) as excinfo:
salt.utils.vmware.wait_for_task(
mock_task, "fake_instance_name", "task_type"
)
self.assertEqual(excinfo.exception.strerror, "SystemError msg")
def test_info_error_invalid_argument_no_fault_message(self):
exc = vmodl.fault.InvalidArgument()
exc.faultMessage = None
exc.msg = "InvalidArgumentFault msg"
mock_task = MagicMock()
prop_mock_state = PropertyMock(return_value="error")
prop_mock_error = PropertyMock(side_effect=exc)
type(mock_task.info).state = prop_mock_state
type(mock_task.info).error = prop_mock_error
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.wait_for_task(
mock_task, "fake_instance_name", "task_type"
)
self.assertEqual(excinfo.exception.strerror, "InvalidArgumentFault msg")
def test_info_error_invalid_argument_with_fault_message(self):
exc = vmodl.fault.InvalidArgument()
fault_message = vim.LocalizableMessage()
fault_message.message = "LocalFault msg"
exc.faultMessage = [fault_message]
exc.msg = "InvalidArgumentFault msg"
mock_task = MagicMock()
prop_mock_state = PropertyMock(return_value="error")
prop_mock_error = PropertyMock(side_effect=exc)
type(mock_task.info).state = prop_mock_state
type(mock_task.info).error = prop_mock_error
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.wait_for_task(
mock_task, "fake_instance_name", "task_type"
)
self.assertEqual(
excinfo.exception.strerror, "InvalidArgumentFault msg (LocalFault msg)"
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetMorsWithPropertiesTestCase(TestCase):
"""
Tests for salt.utils.get_mors_with_properties
"""
si = None
obj_type = None
prop_list = None
container_ref = None
traversal_spec = None
def setUp(self):
self.si = MagicMock()
self.obj_type = MagicMock()
self.prop_list = MagicMock()
self.container_ref = MagicMock()
self.traversal_spec = MagicMock()
def test_empty_content(self):
get_content = MagicMock(return_value=[])
with patch("salt.utils.vmware.get_content", get_content):
ret = salt.utils.vmware.get_mors_with_properties(
self.si,
self.obj_type,
self.prop_list,
self.container_ref,
self.traversal_spec,
)
get_content.assert_called_once_with(
self.si,
self.obj_type,
property_list=self.prop_list,
container_ref=self.container_ref,
traversal_spec=self.traversal_spec,
local_properties=False,
)
self.assertEqual(ret, [])
def test_local_properties_set(self):
obj_mock = MagicMock()
# obj.propSet
propSet_prop = PropertyMock(return_value=[])
type(obj_mock).propSet = propSet_prop
# obj.obj
inner_obj_mock = MagicMock()
obj_prop = PropertyMock(return_value=inner_obj_mock)
type(obj_mock).obj = obj_prop
get_content = MagicMock(return_value=[obj_mock])
with patch("salt.utils.vmware.get_content", get_content):
ret = salt.utils.vmware.get_mors_with_properties(
self.si,
self.obj_type,
self.prop_list,
self.container_ref,
self.traversal_spec,
local_properties=True,
)
get_content.assert_called_once_with(
self.si,
self.obj_type,
property_list=self.prop_list,
container_ref=self.container_ref,
traversal_spec=self.traversal_spec,
local_properties=True,
)
def test_one_element_content(self):
obj_mock = MagicMock()
# obj.propSet
propSet_prop = PropertyMock(return_value=[])
type(obj_mock).propSet = propSet_prop
# obj.obj
inner_obj_mock = MagicMock()
obj_prop = PropertyMock(return_value=inner_obj_mock)
type(obj_mock).obj = obj_prop
get_content = MagicMock(return_value=[obj_mock])
with patch("salt.utils.vmware.get_content", get_content):
ret = salt.utils.vmware.get_mors_with_properties(
self.si,
self.obj_type,
self.prop_list,
self.container_ref,
self.traversal_spec,
)
get_content.assert_called_once_with(
self.si,
self.obj_type,
property_list=self.prop_list,
container_ref=self.container_ref,
traversal_spec=self.traversal_spec,
local_properties=False,
)
self.assertEqual(propSet_prop.call_count, 1)
self.assertEqual(obj_prop.call_count, 1)
self.assertEqual(len(ret), 1)
self.assertDictEqual(ret[0], {"object": inner_obj_mock})
def test_multiple_element_content(self):
# obj1
obj1_mock = MagicMock()
# obj1.propSet
obj1_propSet_prop = PropertyMock(return_value=[])
type(obj1_mock).propSet = obj1_propSet_prop
# obj1.obj
obj1_inner_obj_mock = MagicMock()
obj1_obj_prop = PropertyMock(return_value=obj1_inner_obj_mock)
type(obj1_mock).obj = obj1_obj_prop
# obj2
obj2_mock = MagicMock()
# obj2.propSet
obj2_propSet_prop = PropertyMock(return_value=[])
type(obj2_mock).propSet = obj2_propSet_prop
# obj2.obj
obj2_inner_obj_mock = MagicMock()
obj2_obj_prop = PropertyMock(return_value=obj2_inner_obj_mock)
type(obj2_mock).obj = obj2_obj_prop
get_content = MagicMock(return_value=[obj1_mock, obj2_mock])
with patch("salt.utils.vmware.get_content", get_content):
ret = salt.utils.vmware.get_mors_with_properties(
self.si,
self.obj_type,
self.prop_list,
self.container_ref,
self.traversal_spec,
)
get_content.assert_called_once_with(
self.si,
self.obj_type,
property_list=self.prop_list,
container_ref=self.container_ref,
traversal_spec=self.traversal_spec,
local_properties=False,
)
self.assertEqual(obj1_propSet_prop.call_count, 1)
self.assertEqual(obj2_propSet_prop.call_count, 1)
self.assertEqual(obj1_obj_prop.call_count, 1)
self.assertEqual(obj2_obj_prop.call_count, 1)
self.assertEqual(len(ret), 2)
self.assertDictEqual(ret[0], {"object": obj1_inner_obj_mock})
self.assertDictEqual(ret[1], {"object": obj2_inner_obj_mock})
def test_one_elem_one_property(self):
obj_mock = MagicMock()
# property mock
prop_set_obj_mock = MagicMock()
prop_set_obj_name_prop = PropertyMock(return_value="prop_name")
prop_set_obj_val_prop = PropertyMock(return_value="prop_value")
type(prop_set_obj_mock).name = prop_set_obj_name_prop
type(prop_set_obj_mock).val = prop_set_obj_val_prop
# obj.propSet
propSet_prop = PropertyMock(return_value=[prop_set_obj_mock])
type(obj_mock).propSet = propSet_prop
# obj.obj
inner_obj_mock = MagicMock()
obj_prop = PropertyMock(return_value=inner_obj_mock)
type(obj_mock).obj = obj_prop
get_content = MagicMock(return_value=[obj_mock])
with patch("salt.utils.vmware.get_content", get_content):
ret = salt.utils.vmware.get_mors_with_properties(
self.si,
self.obj_type,
self.prop_list,
self.container_ref,
self.traversal_spec,
local_properties=False,
)
get_content.assert_called_once_with(
self.si,
self.obj_type,
property_list=self.prop_list,
container_ref=self.container_ref,
traversal_spec=self.traversal_spec,
local_properties=False,
)
self.assertEqual(propSet_prop.call_count, 1)
self.assertEqual(prop_set_obj_name_prop.call_count, 1)
self.assertEqual(prop_set_obj_val_prop.call_count, 1)
self.assertEqual(obj_prop.call_count, 1)
self.assertEqual(len(ret), 1)
self.assertDictEqual(
ret[0], {"prop_name": "prop_value", "object": inner_obj_mock}
)
def test_one_elem_multiple_properties(self):
obj_mock = MagicMock()
# property1 mock
prop_set_obj1_mock = MagicMock()
prop_set_obj1_name_prop = PropertyMock(return_value="prop_name1")
prop_set_obj1_val_prop = PropertyMock(return_value="prop_value1")
type(prop_set_obj1_mock).name = prop_set_obj1_name_prop
type(prop_set_obj1_mock).val = prop_set_obj1_val_prop
# property2 mock
prop_set_obj2_mock = MagicMock()
prop_set_obj2_name_prop = PropertyMock(return_value="prop_name2")
prop_set_obj2_val_prop = PropertyMock(return_value="prop_value2")
type(prop_set_obj2_mock).name = prop_set_obj2_name_prop
type(prop_set_obj2_mock).val = prop_set_obj2_val_prop
# obj.propSet
propSet_prop = PropertyMock(
return_value=[prop_set_obj1_mock, prop_set_obj2_mock]
)
type(obj_mock).propSet = propSet_prop
# obj.obj
inner_obj_mock = MagicMock()
obj_prop = PropertyMock(return_value=inner_obj_mock)
type(obj_mock).obj = obj_prop
get_content = MagicMock(return_value=[obj_mock])
with patch("salt.utils.vmware.get_content", get_content):
ret = salt.utils.vmware.get_mors_with_properties(
self.si,
self.obj_type,
self.prop_list,
self.container_ref,
self.traversal_spec,
)
get_content.assert_called_once_with(
self.si,
self.obj_type,
property_list=self.prop_list,
container_ref=self.container_ref,
traversal_spec=self.traversal_spec,
local_properties=False,
)
self.assertEqual(propSet_prop.call_count, 1)
self.assertEqual(prop_set_obj1_name_prop.call_count, 1)
self.assertEqual(prop_set_obj1_val_prop.call_count, 1)
self.assertEqual(prop_set_obj2_name_prop.call_count, 1)
self.assertEqual(prop_set_obj2_val_prop.call_count, 1)
self.assertEqual(obj_prop.call_count, 1)
self.assertEqual(len(ret), 1)
self.assertDictEqual(
ret[0],
{
"prop_name1": "prop_value1",
"prop_name2": "prop_value2",
"object": inner_obj_mock,
},
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetPropertiesOfManagedObjectTestCase(TestCase):
"""
Tests for salt.utils.get_properties_of_managed_object
"""
def setUp(self):
patches = (
("salt.utils.vmware.get_service_instance_from_managed_object", MagicMock()),
(
"salt.utils.vmware.get_mors_with_properties",
MagicMock(return_value=[MagicMock()]),
),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
self.mock_si = MagicMock()
self.fake_mo_ref = vim.ManagedEntity("Fake")
self.mock_props = MagicMock()
self.mock_item_name = {"name": "fake_name"}
self.mock_item = MagicMock()
def test_get_service_instance_from_managed_object_call(self):
mock_get_instance_from_managed_object = MagicMock()
with patch(
"salt.utils.vmware.get_service_instance_from_managed_object",
mock_get_instance_from_managed_object,
):
salt.utils.vmware.get_properties_of_managed_object(
self.fake_mo_ref, self.mock_props
)
mock_get_instance_from_managed_object.assert_called_once_with(self.fake_mo_ref)
def test_get_mors_with_properties_calls(self):
mock_get_mors_with_properties = MagicMock(return_value=[MagicMock()])
with patch(
"salt.utils.vmware.get_service_instance_from_managed_object",
MagicMock(return_value=self.mock_si),
):
with patch(
"salt.utils.vmware.get_mors_with_properties",
mock_get_mors_with_properties,
):
salt.utils.vmware.get_properties_of_managed_object(
self.fake_mo_ref, self.mock_props
)
mock_get_mors_with_properties.assert_has_calls(
[
call(
self.mock_si,
vim.ManagedEntity,
container_ref=self.fake_mo_ref,
property_list=["name"],
local_properties=True,
),
call(
self.mock_si,
vim.ManagedEntity,
container_ref=self.fake_mo_ref,
property_list=self.mock_props,
local_properties=True,
),
]
)
def test_managed_object_no_name_property(self):
with patch(
"salt.utils.vmware.get_mors_with_properties",
MagicMock(side_effect=[vmodl.query.InvalidProperty(), []]),
):
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_properties_of_managed_object(
self.fake_mo_ref, self.mock_props
)
self.assertEqual(
"Properties of managed object '<unnamed>' weren't " "retrieved",
excinfo.exception.strerror,
)
def test_no_items_named_object(self):
with patch(
"salt.utils.vmware.get_mors_with_properties",
MagicMock(side_effect=[[self.mock_item_name], []]),
):
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_properties_of_managed_object(
self.fake_mo_ref, self.mock_props
)
self.assertEqual(
"Properties of managed object 'fake_name' weren't " "retrieved",
excinfo.exception.strerror,
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetManagedObjectName(TestCase):
"""
Tests for salt.utils.get_managed_object_name
"""
def setUp(self):
patches = (
(
"salt.utils.vmware.get_properties_of_managed_object",
MagicMock(return_value={"key": "value"}),
),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
self.mock_mo_ref = MagicMock()
def test_get_properties_of_managed_object_call(self):
mock_get_properties_of_managed_object = MagicMock()
with patch(
"salt.utils.vmware.get_properties_of_managed_object",
mock_get_properties_of_managed_object,
):
salt.utils.vmware.get_managed_object_name(self.mock_mo_ref)
mock_get_properties_of_managed_object.assert_called_once_with(
self.mock_mo_ref, ["name"]
)
def test_no_name_in_property_dict(self):
ret = salt.utils.vmware.get_managed_object_name(self.mock_mo_ref)
self.assertIsNone(ret)
def test_return_managed_object_name(self):
mock_get_properties_of_managed_object = MagicMock()
with patch(
"salt.utils.vmware.get_properties_of_managed_object",
MagicMock(return_value={"name": "fake_name"}),
):
ret = salt.utils.vmware.get_managed_object_name(self.mock_mo_ref)
self.assertEqual(ret, "fake_name")
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetContentTestCase(TestCase):
"""
Tests for salt.utils.get_content
"""
# Method names to be patched
traversal_spec_method_name = (
"salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec"
)
property_spec_method_name = (
"salt.utils.vmware.vmodl.query.PropertyCollector.PropertySpec"
)
obj_spec_method_name = "salt.utils.vmware.vmodl.query.PropertyCollector.ObjectSpec"
filter_spec_method_name = (
"salt.utils.vmware.vmodl.query.PropertyCollector.FilterSpec"
)
# Class variables
si_mock = None
root_folder_mock = None
root_folder_prop = None
container_view_mock = None
create_container_view_mock = None
result_mock = None
retrieve_contents_mock = None
destroy_mock = None
obj_type_mock = None
traversal_spec_ret_mock = None
traversal_spec_mock = None
property_spec_ret_mock = None
property_spec_mock = None
obj_spec_ret_mock = None
obj_spec_mock = None
filter_spec_ret_mock = None
filter_spec_mock = None
def setUp(self):
patches = (
("salt.utils.vmware.get_root_folder", MagicMock()),
(
"salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec",
MagicMock(return_value=MagicMock()),
),
(
"salt.utils.vmware.vmodl.query.PropertyCollector.PropertySpec",
MagicMock(return_value=MagicMock()),
),
(
"salt.utils.vmware.vmodl.query.PropertyCollector.ObjectSpec",
MagicMock(return_value=MagicMock()),
),
(
"salt.utils.vmware.vmodl.query.PropertyCollector.FilterSpec",
MagicMock(return_value=MagicMock()),
),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
# setup the service instance
self.si_mock = MagicMock()
# RootFolder
self.root_folder_mock = MagicMock()
self.get_root_folder_mock = MagicMock(return_value=self.root_folder_mock)
# CreateContainerView()
self.container_view_mock = MagicMock()
self.create_container_view_mock = MagicMock(
return_value=self.container_view_mock
)
self.si_mock.content.viewManager.CreateContainerView = (
self.create_container_view_mock
)
# RetrieveContents()
self.result_mock = MagicMock()
self.retrieve_contents_mock = MagicMock(return_value=self.result_mock)
self.si_mock.content.propertyCollector.RetrieveContents = (
self.retrieve_contents_mock
)
# Destroy()
self.destroy_mock = MagicMock()
self.container_view_mock.Destroy = self.destroy_mock
# override mocks
self.obj_type_mock = MagicMock()
self.traversal_spec_ret_mock = MagicMock()
self.traversal_spec_mock = MagicMock(return_value=self.traversal_spec_ret_mock)
self.property_spec_ret_mock = MagicMock()
self.property_spec_mock = MagicMock(return_value=self.property_spec_ret_mock)
self.obj_spec_ret_mock = MagicMock()
self.obj_spec_mock = MagicMock(return_value=self.obj_spec_ret_mock)
self.filter_spec_ret_mock = MagicMock()
self.filter_spec_mock = MagicMock(return_value=self.filter_spec_ret_mock)
def test_empty_container_ref(self):
with patch("salt.utils.vmware.get_root_folder", self.get_root_folder_mock):
salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock)
self.get_root_folder_mock.assert_called_once_with(self.si_mock)
self.create_container_view_mock.assert_called_once_with(
self.root_folder_mock, [self.obj_type_mock], True
)
def test_defined_container_ref(self):
container_ref_mock = MagicMock()
with patch("salt.utils.vmware.get_root_folder", self.get_root_folder_mock):
with patch(self.obj_spec_method_name, self.obj_type_mock):
salt.utils.vmware.get_content(
self.si_mock, self.obj_type_mock, container_ref=container_ref_mock
)
self.assertEqual(self.get_root_folder_mock.call_count, 0)
self.create_container_view_mock.assert_called_once_with(
container_ref_mock, [self.obj_type_mock], True
)
# Also checks destroy is called
def test_local_traversal_spec(self):
with patch("salt.utils.vmware.get_root_folder", self.get_root_folder_mock):
with patch(self.traversal_spec_method_name, self.traversal_spec_mock):
with patch(self.obj_spec_method_name, self.obj_spec_mock):
ret = salt.utils.vmware.get_content(
self.si_mock, self.obj_type_mock
)
self.create_container_view_mock.assert_called_once_with(
self.root_folder_mock, [self.obj_type_mock], True
)
self.traversal_spec_mock.assert_called_once_with(
name="traverseEntities",
path="view",
skip=False,
type=vim.view.ContainerView,
)
self.obj_spec_mock.assert_called_once_with(
obj=self.container_view_mock,
skip=True,
selectSet=[self.traversal_spec_ret_mock],
)
# check destroy is called
self.assertEqual(self.destroy_mock.call_count, 1)
def test_create_container_view_raise_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
self.si_mock.content.viewManager.CreateContainerView = MagicMock(
side_effect=exc
)
with patch("salt.utils.vmware.get_root_folder", self.get_root_folder_mock):
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_create_container_view_raise_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
self.si_mock.content.viewManager.CreateContainerView = MagicMock(
side_effect=exc
)
with patch("salt.utils.vmware.get_root_folder", self.get_root_folder_mock):
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_create_container_view_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
self.si_mock.content.viewManager.CreateContainerView = MagicMock(
side_effect=exc
)
with patch("salt.utils.vmware.get_root_folder", self.get_root_folder_mock):
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_destroy_raise_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
self.si_mock.content.viewManager.CreateContainerView = MagicMock(
return_value=MagicMock(Destroy=MagicMock(side_effect=exc))
)
with patch("salt.utils.vmware.get_root_folder", self.get_root_folder_mock):
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_destroy_raise_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
self.si_mock.content.viewManager.CreateContainerView = MagicMock(
return_value=MagicMock(Destroy=MagicMock(side_effect=exc))
)
with patch("salt.utils.vmware.get_root_folder", self.get_root_folder_mock):
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_destroy_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
self.si_mock.content.viewManager.CreateContainerView = MagicMock(
return_value=MagicMock(Destroy=MagicMock(side_effect=exc))
)
with patch("salt.utils.vmware.get_root_folder", self.get_root_folder_mock):
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
# Also checks destroy is not called
def test_external_traversal_spec(self):
traversal_spec_obj_mock = MagicMock()
with patch("salt.utils.vmware.get_root_folder", self.get_root_folder_mock):
with patch(self.traversal_spec_method_name, self.traversal_spec_mock):
with patch(self.obj_spec_method_name, self.obj_spec_mock):
salt.utils.vmware.get_content(
self.si_mock,
self.obj_type_mock,
traversal_spec=traversal_spec_obj_mock,
)
self.obj_spec_mock.assert_called_once_with(
obj=self.root_folder_mock, skip=True, selectSet=[traversal_spec_obj_mock]
)
# Check local traversal methods are not called
self.assertEqual(self.create_container_view_mock.call_count, 0)
self.assertEqual(self.traversal_spec_mock.call_count, 0)
# check destroy is not called
self.assertEqual(self.destroy_mock.call_count, 0)
def test_property_obj_filter_specs_and_contents(self):
with patch(self.traversal_spec_method_name, self.traversal_spec_mock):
with patch(self.property_spec_method_name, self.property_spec_mock):
with patch(self.obj_spec_method_name, self.obj_spec_mock):
with patch(self.filter_spec_method_name, self.filter_spec_mock):
ret = salt.utils.vmware.get_content(
self.si_mock, self.obj_type_mock
)
self.traversal_spec_mock.assert_called_once_with(
name="traverseEntities",
path="view",
skip=False,
type=vim.view.ContainerView,
)
self.property_spec_mock.assert_called_once_with(
type=self.obj_type_mock, all=True, pathSet=None
)
self.obj_spec_mock.assert_called_once_with(
obj=self.container_view_mock,
skip=True,
selectSet=[self.traversal_spec_ret_mock],
)
self.retrieve_contents_mock.assert_called_once_with([self.filter_spec_ret_mock])
self.assertEqual(ret, self.result_mock)
def test_retrieve_contents_raise_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
self.si_mock.content.propertyCollector.RetrieveContents = MagicMock(
side_effect=exc
)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_retrieve_contents_raise_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
self.si_mock.content.propertyCollector.RetrieveContents = MagicMock(
side_effect=exc
)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_retrieve_contents_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
self.si_mock.content.propertyCollector.RetrieveContents = MagicMock(
side_effect=exc
)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_local_properties_set(self):
container_ref_mock = MagicMock()
with patch(self.traversal_spec_method_name, self.traversal_spec_mock):
with patch(self.property_spec_method_name, self.property_spec_mock):
with patch(self.obj_spec_method_name, self.obj_spec_mock):
salt.utils.vmware.get_content(
self.si_mock,
self.obj_type_mock,
container_ref=container_ref_mock,
local_properties=True,
)
self.assertEqual(self.traversal_spec_mock.call_count, 0)
self.obj_spec_mock.assert_called_once_with(
obj=container_ref_mock, skip=False, selectSet=None
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetRootFolderTestCase(TestCase):
"""
Tests for salt.utils.get_root_folder
"""
def setUp(self):
self.mock_root_folder = MagicMock()
self.mock_content = MagicMock(rootFolder=self.mock_root_folder)
self.mock_si = MagicMock(
RetrieveContent=MagicMock(return_value=self.mock_content)
)
def test_raise_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
type(self.mock_content).rootFolder = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_root_folder(self.mock_si)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_raise_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
type(self.mock_content).rootFolder = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_root_folder(self.mock_si)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
type(self.mock_content).rootFolder = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.get_root_folder(self.mock_si)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_return(self):
ret = salt.utils.vmware.get_root_folder(self.mock_si)
self.assertEqual(ret, self.mock_root_folder)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetServiceInfoTestCase(TestCase):
"""
Tests for salt.utils.vmware.get_service_info
"""
def setUp(self):
self.mock_about = MagicMock()
self.mock_si = MagicMock(content=MagicMock())
type(self.mock_si.content).about = PropertyMock(return_value=self.mock_about)
def tearDown(self):
for attr in ("mock_si", "mock_about"):
delattr(self, attr)
def test_about_ret(self):
ret = salt.utils.vmware.get_service_info(self.mock_si)
self.assertEqual(ret, self.mock_about)
def test_about_raises_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
type(self.mock_si.content).about = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_service_info(self.mock_si)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_about_raises_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
type(self.mock_si.content).about = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_service_info(self.mock_si)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_about_raises_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
type(self.mock_si.content).about = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.get_service_info(self.mock_si)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
@skipIf(not HAS_GSSAPI, "The 'gssapi' library is missing")
class GssapiTokenTest(TestCase):
"""
Test cases for salt.utils.vmware.get_gssapi_token
"""
def setUp(self):
patches = (
("gssapi.Name", MagicMock(return_value="service")),
("gssapi.InitContext", MagicMock()),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def test_no_gssapi(self):
with patch("salt.utils.vmware.HAS_GSSAPI", False):
with self.assertRaises(ImportError) as excinfo:
salt.utils.vmware.get_gssapi_token("principal", "host", "domain")
self.assertIn(
"The gssapi library is not imported.", excinfo.exception.message
)
@skipIf(not HAS_GSSAPI, "The 'gssapi' library is missing")
def test_service_name(self):
mock_name = MagicMock()
with patch.object(salt.utils.vmware.gssapi, "Name", mock_name):
with self.assertRaises(CommandExecutionError):
salt.utils.vmware.get_gssapi_token("principal", "host", "domain")
mock_name.assert_called_once_with(
"principal/host@domain", gssapi.C_NT_USER_NAME
)
@skipIf(not HAS_GSSAPI, "The 'gssapi' library is missing")
def test_out_token_defined(self):
mock_context = MagicMock(return_value=MagicMock())
mock_context.return_value.established = False
mock_context.return_value.step = MagicMock(return_value="out_token")
with patch.object(salt.utils.vmware.gssapi, "InitContext", mock_context):
ret = salt.utils.vmware.get_gssapi_token("principal", "host", "domain")
self.assertEqual(mock_context.return_value.step.called, 1)
self.assertEqual(ret, base64.b64encode(b"out_token"))
@skipIf(not HAS_GSSAPI, "The 'gssapi' library is missing")
def test_out_token_undefined(self):
mock_context = MagicMock(return_value=MagicMock())
mock_context.return_value.established = False
mock_context.return_value.step = MagicMock(return_value=None)
with patch.object(salt.utils.vmware.gssapi, "InitContext", mock_context):
with self.assertRaises(CommandExecutionError) as excinfo:
salt.utils.vmware.get_gssapi_token("principal", "host", "domain")
self.assertEqual(mock_context.return_value.step.called, 1)
self.assertIn("Can't receive token", excinfo.exception.strerror)
@skipIf(not HAS_GSSAPI, "The 'gssapi' library is missing")
def test_context_extablished(self):
mock_context = MagicMock(return_value=MagicMock())
mock_context.return_value.established = True
mock_context.return_value.step = MagicMock(return_value="out_token")
with patch.object(salt.utils.vmware.gssapi, "InitContext", mock_context):
mock_context.established = True
mock_context.step = MagicMock(return_value=None)
with self.assertRaises(CommandExecutionError) as excinfo:
salt.utils.vmware.get_gssapi_token("principal", "host", "domain")
self.assertEqual(mock_context.step.called, 0)
self.assertIn(
"Context established, but didn't receive token",
excinfo.exception.strerror,
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class PrivateGetServiceInstanceTestCase(TestCase):
"""
Tests for salt.utils.vmware._get_service_instance
"""
def setUp(self):
patches = (
("salt.utils.vmware.SmartConnect", MagicMock()),
("salt.utils.vmware.Disconnect", MagicMock()),
(
"salt.utils.vmware.get_gssapi_token",
MagicMock(return_value="fake_token"),
),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def test_invalid_mechianism(self):
with self.assertRaises(CommandExecutionError) as excinfo:
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="invalid_mechanism",
principal="fake principal",
domain="fake_domain",
)
self.assertIn("Unsupported mechanism", excinfo.exception.strerror)
def test_userpass_mechanism_empty_username(self):
with self.assertRaises(CommandExecutionError) as excinfo:
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username=None,
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="userpass",
principal="fake principal",
domain="fake_domain",
)
self.assertIn("mandatory parameter 'username'", excinfo.exception.strerror)
def test_userpass_mechanism_empty_password(self):
with self.assertRaises(CommandExecutionError) as excinfo:
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username="fake_username",
password=None,
protocol="fake_protocol",
port=1,
mechanism="userpass",
principal="fake principal",
domain="fake_domain",
)
self.assertIn("mandatory parameter 'password'", excinfo.exception.strerror)
def test_userpass_mechanism_no_domain(self):
mock_sc = MagicMock()
with patch("salt.utils.vmware.SmartConnect", mock_sc):
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="userpass",
principal="fake principal",
domain=None,
)
mock_sc.assert_called_once_with(
host="fake_host.fqdn",
user="fake_username",
pwd="fake_password",
protocol="fake_protocol",
port=1,
b64token=None,
mechanism="userpass",
)
def test_userpass_mech_domain_unused(self):
mock_sc = MagicMock()
with patch("salt.utils.vmware.SmartConnect", mock_sc):
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username="fake_username@domain",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="userpass",
principal="fake principal",
domain="fake_domain",
)
mock_sc.assert_called_once_with(
host="fake_host.fqdn",
user="fake_username@domain",
pwd="fake_password",
protocol="fake_protocol",
port=1,
b64token=None,
mechanism="userpass",
)
mock_sc.reset_mock()
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username="domain\\fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="userpass",
principal="fake principal",
domain="fake_domain",
)
mock_sc.assert_called_once_with(
host="fake_host.fqdn",
user="domain\\fake_username",
pwd="fake_password",
protocol="fake_protocol",
port=1,
b64token=None,
mechanism="userpass",
)
def test_sspi_empty_principal(self):
with self.assertRaises(CommandExecutionError) as excinfo:
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="sspi",
principal=None,
domain="fake_domain",
)
self.assertIn("mandatory parameters are missing", excinfo.exception.strerror)
def test_sspi_empty_domain(self):
with self.assertRaises(CommandExecutionError) as excinfo:
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="sspi",
principal="fake_principal",
domain=None,
)
self.assertIn("mandatory parameters are missing", excinfo.exception.strerror)
def test_sspi_get_token_error(self):
mock_token = MagicMock(side_effect=Exception("Exception"))
with patch("salt.utils.vmware.get_gssapi_token", mock_token):
with self.assertRaises(VMwareConnectionError) as excinfo:
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="sspi",
principal="fake_principal",
domain="fake_domain",
)
mock_token.assert_called_once_with(
"fake_principal", "fake_host.fqdn", "fake_domain"
)
self.assertEqual("Exception", excinfo.exception.strerror)
def test_sspi_get_token_success_(self):
mock_token = MagicMock(return_value="fake_token")
mock_sc = MagicMock()
with patch("salt.utils.vmware.get_gssapi_token", mock_token):
with patch("salt.utils.vmware.SmartConnect", mock_sc):
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="sspi",
principal="fake_principal",
domain="fake_domain",
)
mock_token.assert_called_once_with(
"fake_principal", "fake_host.fqdn", "fake_domain"
)
mock_sc.assert_called_once_with(
host="fake_host.fqdn",
user="fake_username",
pwd="fake_password",
protocol="fake_protocol",
port=1,
b64token="fake_token",
mechanism="sspi",
)
def test_first_attempt_successful_connection(self):
mock_sc = MagicMock()
with patch("salt.utils.vmware.SmartConnect", mock_sc):
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="sspi",
principal="fake_principal",
domain="fake_domain",
)
mock_sc.assert_called_once_with(
host="fake_host.fqdn",
user="fake_username",
pwd="fake_password",
protocol="fake_protocol",
port=1,
b64token="fake_token",
mechanism="sspi",
)
def test_first_attempt_successful_connection_verify_ssl_false(self):
with patch("ssl.SSLContext", MagicMock()), patch(
"ssl._create_unverified_context", MagicMock()
):
exc = vim.fault.HostConnectFault()
exc.msg = "[SSL: CERTIFICATE_VERIFY_FAILED]"
mock_sc = MagicMock(side_effect=[None])
mock_ssl = MagicMock()
with patch("salt.utils.vmware.SmartConnect", mock_sc):
with patch("ssl._create_unverified_context", mock_ssl):
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="sspi",
principal="fake_principal",
domain="fake_domain",
verify_ssl=False,
)
mock_ssl.assert_called_once_with()
calls = [
call(
host="fake_host.fqdn",
user="fake_username",
pwd="fake_password",
protocol="fake_protocol",
port=1,
sslContext=mock_ssl.return_value,
b64token="fake_token",
mechanism="sspi",
),
]
mock_sc.assert_has_calls(calls)
def test_second_attempt_successful_connection_verify_ssl_false(self):
with patch("ssl.SSLContext", MagicMock()), patch(
"ssl._create_unverified_context", MagicMock()
):
exc = Exception("certificate verify failed")
mock_sc = MagicMock(side_effect=[exc, None])
mock_ssl_unverif = MagicMock()
mock_ssl_context = MagicMock()
with patch("salt.utils.vmware.SmartConnect", mock_sc):
with patch("ssl._create_unverified_context", mock_ssl_unverif):
with patch("ssl.SSLContext", mock_ssl_context):
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="sspi",
principal="fake_principal",
domain="fake_domain",
verify_ssl=False
)
mock_ssl_context.assert_called_once_with(ssl.PROTOCOL_TLSv1)
mock_ssl_unverif.assert_called_once_with()
calls = [
call(
host="fake_host.fqdn",
user="fake_username",
pwd="fake_password",
protocol="fake_protocol",
port=1,
sslContext=mock_ssl_unverif.return_value,
b64token="fake_token",
mechanism="sspi",
),
call(
host="fake_host.fqdn",
user="fake_username",
pwd="fake_password",
protocol="fake_protocol",
port=1,
sslContext=mock_ssl_context.return_value,
b64token="fake_token",
mechanism="sspi",
),
]
mock_sc.assert_has_calls(calls)
def test_attempt_unsuccessful_connection_default_error(self):
exc = Exception("Exception")
mock_sc = MagicMock(side_effect=exc)
with patch("salt.utils.vmware.SmartConnect", mock_sc):
with self.assertRaises(VMwareConnectionError) as excinfo:
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="sspi",
principal="fake_principal",
domain="fake_domain",
)
self.assertEqual(mock_sc.call_count, 1)
self.assertIn(
"Could not connect to host 'fake_host.fqdn'",
excinfo.exception.message,
)
def test_attempt_unsuccessful_connection_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault"
mock_sc = MagicMock(side_effect=exc)
with patch("salt.utils.vmware.SmartConnect", mock_sc):
with self.assertRaises(VMwareConnectionError) as excinfo:
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="sspi",
principal="fake_principal",
domain="fake_domain",
)
self.assertEqual(mock_sc.call_count, 1)
self.assertEqual("VimFault", excinfo.exception.message)
def test_first_attempt_unsuccsessful_connection_default_error(self):
with patch("ssl.SSLContext", MagicMock()), patch(
"ssl._create_unverified_context", MagicMock()
):
exc = vim.fault.HostConnectFault()
exc.msg = "certificate verify failed"
exc2 = Exception("Exception")
mock_sc = MagicMock(side_effect=[exc, exc2])
with patch("salt.utils.vmware.SmartConnect", mock_sc):
with self.assertRaises(VMwareConnectionError) as excinfo:
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="sspi",
principal="fake_principal",
domain="fake_domain",
verify_ssl=False,
)
self.assertEqual(mock_sc.call_count, 2)
self.assertIn(
"Could not connect to host 'fake_host.fqdn'",
excinfo.exception.message
)
def test_first_attempt_unsuccsessful_cannot_vim_fault_verify_ssl(self):
with patch("ssl.SSLContext", MagicMock()), patch(
"ssl._create_unverified_context", MagicMock()
):
exc = vim.fault.VimFault()
exc.msg = "VimFault"
mock_sc = MagicMock(side_effect=[exc])
with patch("salt.utils.vmware.SmartConnect", mock_sc):
with self.assertRaises(VMwareConnectionError) as excinfo:
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="sspi",
principal="fake_principal",
domain="fake_domain",
verify_ssl=False,
)
self.assertEqual(mock_sc.call_count, 1)
self.assertIn("VimFault", excinfo.exception.message)
def test_third_attempt_unsuccessful_connection_detault_error(self):
with patch("ssl.SSLContext", MagicMock()), patch(
"ssl._create_unverified_context", MagicMock()
):
exc = vim.fault.HostConnectFault()
exc.msg = "certificate verify failed"
exc2 = Exception("Exception")
mock_sc = MagicMock(side_effect=[exc, exc2])
with patch("salt.utils.vmware.SmartConnect", mock_sc):
with self.assertRaises(VMwareConnectionError) as excinfo:
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="sspi",
principal="fake_principal",
domain="fake_domain",
verify_ssl=False
)
self.assertEqual(mock_sc.call_count, 2)
self.assertIn("Could not connect to host 'fake_host.fqdn", excinfo.exception.message)
def test_second_attempt_unsuccessful_connection_vim_fault(self):
with patch("ssl.SSLContext", MagicMock()), patch(
"ssl._create_unverified_context", MagicMock()
):
exc = vim.fault.VimFault()
exc.msg = "VimFault"
mock_sc = MagicMock(side_effect=[exc])
with patch("salt.utils.vmware.SmartConnect", mock_sc):
with self.assertRaises(VMwareConnectionError) as excinfo:
salt.utils.vmware._get_service_instance(
host="fake_host.fqdn",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="sspi",
principal="fake_principal",
domain="fake_domain",
verify_ssl=False
)
self.assertEqual(mock_sc.call_count, 1)
self.assertIn("VimFault", excinfo.exception.message)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetServiceInstanceTestCase(TestCase):
"""
Tests for salt.utils.vmware.get_service_instance
"""
def setUp(self):
patches = (
("salt.utils.vmware.GetSi", MagicMock(return_value=None)),
(
"salt.utils.vmware._get_service_instance",
MagicMock(return_value=MagicMock()),
),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def test_default_params(self):
mock_get_si = MagicMock()
with patch("salt.utils.vmware._get_service_instance", mock_get_si):
salt.utils.vmware.get_service_instance(host="fake_host")
mock_get_si.assert_called_once_with(
"fake_host", None, None, "https", 443, "userpass", None, None,
verify_ssl=True
)
def test_no_cached_service_instance_same_host_on_proxy(self):
with patch("salt.utils.platform.is_proxy", MagicMock(return_value=True)):
# Service instance is uncached when using class default mock objs
mock_get_si = MagicMock()
with patch("salt.utils.vmware._get_service_instance", mock_get_si):
salt.utils.vmware.get_service_instance(
host="fake_host",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="fake_mechanism",
principal="fake_principal",
domain="fake_domain",
)
mock_get_si.assert_called_once_with(
"fake_host",
"fake_username",
"fake_password",
"fake_protocol",
1,
"fake_mechanism",
"fake_principal",
"fake_domain",
verify_ssl=True,
)
def test_cached_service_instance_different_host(self):
mock_si = MagicMock()
mock_disconnect = MagicMock()
mock_get_si = MagicMock(return_value=mock_si)
mock_getstub = MagicMock()
with patch("salt.utils.vmware.GetSi", mock_get_si):
with patch("salt.utils.vmware.GetStub", mock_getstub):
with patch("salt.utils.vmware.Disconnect", mock_disconnect):
salt.utils.vmware.get_service_instance(
host="fake_host",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="fake_mechanism",
principal="fake_principal",
domain="fake_domain",
)
self.assertEqual(mock_get_si.call_count, 1)
self.assertEqual(mock_getstub.call_count, 1)
self.assertEqual(mock_disconnect.call_count, 1)
def test_uncached_service_instance(self):
# Service instance is uncached when using class default mock objs
mock_get_si = MagicMock()
with patch("salt.utils.vmware._get_service_instance", mock_get_si):
salt.utils.vmware.get_service_instance(
host="fake_host",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="fake_mechanism",
principal="fake_principal",
domain="fake_domain",
verify_ssl=True
)
mock_get_si.assert_called_once_with(
"fake_host",
"fake_username",
"fake_password",
"fake_protocol",
1,
"fake_mechanism",
"fake_principal",
"fake_domain",
verify_ssl=True,
)
def test_unauthenticated_service_instance(self):
mock_si_current_time = MagicMock(side_effect=vim.fault.NotAuthenticated)
mock_si = MagicMock()
mock_get_si = MagicMock(return_value=mock_si)
mock_si.CurrentTime = mock_si_current_time
mock_disconnect = MagicMock()
with patch("salt.utils.vmware._get_service_instance", mock_get_si):
with patch("salt.utils.vmware.Disconnect", mock_disconnect):
salt.utils.vmware.get_service_instance(
host="fake_host",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="fake_mechanism",
principal="fake_principal",
domain="fake_domain",
)
self.assertEqual(mock_si_current_time.call_count, 1)
self.assertEqual(mock_disconnect.call_count, 1)
self.assertEqual(mock_get_si.call_count, 2)
def test_cached_unauthenticated_service_instance(self):
mock_si_current_time = MagicMock(side_effect=vim.fault.NotAuthenticated)
mock_si = MagicMock()
mock_get_si = MagicMock(return_value=mock_si)
mock_getsi = MagicMock(return_value=mock_si)
mock_si.CurrentTime = mock_si_current_time
mock_disconnect = MagicMock()
with patch("salt.utils.vmware.GetSi", mock_getsi):
with patch("salt.utils.vmware._get_service_instance", mock_get_si):
with patch("salt.utils.vmware.Disconnect", mock_disconnect):
salt.utils.vmware.get_service_instance(
host="fake_host",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="fake_mechanism",
principal="fake_principal",
domain="fake_domain",
)
self.assertEqual(mock_si_current_time.call_count, 1)
self.assertEqual(mock_disconnect.call_count, 1)
self.assertEqual(mock_get_si.call_count, 1)
def test_current_time_raise_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
with patch(
"salt.utils.vmware._get_service_instance",
MagicMock(return_value=MagicMock(CurrentTime=MagicMock(side_effect=exc))),
):
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_service_instance(
host="fake_host",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="fake_mechanism",
principal="fake_principal",
domain="fake_domain",
)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_current_time_raise_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
with patch(
"salt.utils.vmware._get_service_instance",
MagicMock(return_value=MagicMock(CurrentTime=MagicMock(side_effect=exc))),
):
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_service_instance(
host="fake_host",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="fake_mechanism",
principal="fake_principal",
domain="fake_domain",
)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_current_time_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
with patch(
"salt.utils.vmware._get_service_instance",
MagicMock(return_value=MagicMock(CurrentTime=MagicMock(side_effect=exc))),
):
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.get_service_instance(
host="fake_host",
username="fake_username",
password="fake_password",
protocol="fake_protocol",
port=1,
mechanism="fake_mechanism",
principal="fake_principal",
domain="fake_domain",
)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class DisconnectTestCase(TestCase):
"""
Tests for salt.utils.vmware.disconnect
"""
def setUp(self):
self.mock_si = MagicMock()
self.addCleanup(delattr, self, "mock_si")
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)
def test_disconnect_raise_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
with patch("salt.utils.vmware.Disconnect", MagicMock(side_effect=exc)):
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.disconnect(service_instance=self.mock_si)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_disconnect_raise_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
with patch("salt.utils.vmware.Disconnect", MagicMock(side_effect=exc)):
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.disconnect(service_instance=self.mock_si)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_disconnect_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
with patch("salt.utils.vmware.Disconnect", MagicMock(side_effect=exc)):
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.disconnect(service_instance=self.mock_si)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class IsConnectionToAVCenterTestCase(TestCase):
"""
Tests for salt.utils.vmware.is_connection_to_a_vcenter
"""
def test_api_type_raise_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
mock_si = MagicMock()
type(mock_si.content.about).apiType = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.is_connection_to_a_vcenter(mock_si)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_api_type_raise_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
mock_si = MagicMock()
type(mock_si.content.about).apiType = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.is_connection_to_a_vcenter(mock_si)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_api_type_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
mock_si = MagicMock()
type(mock_si.content.about).apiType = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.is_connection_to_a_vcenter(mock_si)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_connected_to_a_vcenter(self):
mock_si = MagicMock()
mock_si.content.about.apiType = "VirtualCenter"
ret = salt.utils.vmware.is_connection_to_a_vcenter(mock_si)
self.assertTrue(ret)
def test_connected_to_a_host(self):
mock_si = MagicMock()
mock_si.content.about.apiType = "HostAgent"
ret = salt.utils.vmware.is_connection_to_a_vcenter(mock_si)
self.assertFalse(ret)
def test_connected_to_invalid_entity(self):
mock_si = MagicMock()
mock_si.content.about.apiType = "UnsupportedType"
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.is_connection_to_a_vcenter(mock_si)
self.assertIn(
"Unexpected api type 'UnsupportedType'", excinfo.exception.strerror
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetNewServiceInstanceStub(TestCase, LoaderModuleMockMixin):
"""
Tests for salt.utils.vmware.get_new_service_instance_stub
"""
def setup_loader_modules(self):
return {salt.utils.vmware: {"sys": MagicMock(), "ssl": MagicMock()}}
def setUp(self):
self.mock_stub = MagicMock(host="fake_host:1000", cookie='ignore"fake_cookie')
self.mock_si = MagicMock(_stub=self.mock_stub)
self.mock_ret = MagicMock()
self.mock_new_stub = MagicMock()
self.context_dict = {}
patches = (
(
"salt.utils.vmware.VmomiSupport.GetRequestContext",
MagicMock(return_value=self.context_dict),
),
(
"salt.utils.vmware.SoapStubAdapter",
MagicMock(return_value=self.mock_new_stub),
),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
self.mock_context = MagicMock()
self.mock_create_default_context = MagicMock(return_value=self.mock_context)
salt.utils.vmware.ssl.create_default_context = self.mock_create_default_context
def tearDown(self):
for attr in (
"mock_stub",
"mock_si",
"mock_ret",
"mock_new_stub",
"context_dict",
"mock_context",
"mock_create_default_context",
):
delattr(self, attr)
def test_ssl_default_context_loaded(self):
salt.utils.vmware.get_new_service_instance_stub(self.mock_si, "fake_path")
self.mock_create_default_context.assert_called_once_with()
self.assertFalse(self.mock_context.check_hostname)
self.assertEqual(self.mock_context.verify_mode, salt.utils.vmware.ssl.CERT_NONE)
def test_session_cookie_in_context(self):
salt.utils.vmware.get_new_service_instance_stub(self.mock_si, "fake_path")
self.assertEqual(self.context_dict["vcSessionCookie"], "fake_cookie")
def test_get_new_stub(self):
mock_get_new_stub = MagicMock()
with patch("salt.utils.vmware.SoapStubAdapter", mock_get_new_stub):
salt.utils.vmware.get_new_service_instance_stub(
self.mock_si, "fake_path", "fake_ns", "fake_version"
)
mock_get_new_stub.assert_called_once_with(
host="fake_host",
ns="fake_ns",
path="fake_path",
version="fake_version",
poolSize=0,
sslContext=self.mock_context,
)
def test_new_stub_returned(self):
ret = salt.utils.vmware.get_new_service_instance_stub(self.mock_si, "fake_path")
self.assertEqual(self.mock_new_stub.cookie, 'ignore"fake_cookie')
self.assertEqual(ret, self.mock_new_stub)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetServiceInstanceFromManagedObjectTestCase(TestCase):
"""
Tests for salt.utils.vmware.get_managed_instance_from_managed_object
"""
def setUp(self):
patches = (("salt.utils.vmware.vim.ServiceInstance", MagicMock()),)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
self.mock_si = MagicMock()
self.mock_stub = PropertyMock()
self.mock_mo_ref = MagicMock(_stub=self.mock_stub)
for attr in ("mock_si", "mock_stub", "mock_mo_ref"):
self.addCleanup(delattr, self, attr)
def test_default_name_parameter(self):
mock_trace = MagicMock()
type(salt.utils.vmware.log).trace = mock_trace
salt.utils.vmware.get_service_instance_from_managed_object(self.mock_mo_ref)
mock_trace.assert_called_once_with(
"[%s] Retrieving service instance from managed object", "<unnamed>"
)
def test_name_parameter_passed_in(self):
mock_trace = MagicMock()
type(salt.utils.vmware.log).trace = mock_trace
salt.utils.vmware.get_service_instance_from_managed_object(
self.mock_mo_ref, "fake_mo_name"
)
mock_trace.assert_called_once_with(
"[%s] Retrieving service instance from managed object", "fake_mo_name"
)
def test_service_instance_instantiation(self):
mock_service_instance_ini = MagicMock()
with patch("salt.utils.vmware.vim.ServiceInstance", mock_service_instance_ini):
salt.utils.vmware.get_service_instance_from_managed_object(self.mock_mo_ref)
mock_service_instance_ini.assert_called_once_with("ServiceInstance")
def test_si_return_and_stub_assignment(self):
with patch(
"salt.utils.vmware.vim.ServiceInstance",
MagicMock(return_value=self.mock_si),
):
ret = salt.utils.vmware.get_service_instance_from_managed_object(
self.mock_mo_ref
)
self.assertEqual(ret, self.mock_si)
self.assertEqual(ret._stub, self.mock_stub)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetDatacentersTestCase(TestCase):
"""
Tests for salt.utils.vmware.get_datacenters
"""
def setUp(self):
patches = (
(
"salt.utils.vmware.get_mors_with_properties",
MagicMock(return_value=[{"name": "fake_dc", "object": MagicMock()}]),
),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
self.mock_si = MagicMock()
self.mock_dc1 = MagicMock()
self.mock_dc2 = MagicMock()
self.mock_entries = [
{"name": "fake_dc1", "object": self.mock_dc1},
{"name": "fake_dc2", "object": self.mock_dc2},
]
def test_get_mors_with_properties_call(self):
mock_get_mors_with_properties = MagicMock(
return_value=[{"name": "fake_dc", "object": MagicMock()}]
)
with patch(
"salt.utils.vmware.get_mors_with_properties", mock_get_mors_with_properties
):
salt.utils.vmware.get_datacenters(
self.mock_si, datacenter_names=["fake_dc1"]
)
mock_get_mors_with_properties.assert_called_once_with(
self.mock_si, vim.Datacenter, property_list=["name"]
)
def test_get_mors_with_properties_returns_empty_array(self):
with patch(
"salt.utils.vmware.get_mors_with_properties", MagicMock(return_value=[])
):
res = salt.utils.vmware.get_datacenters(
self.mock_si, datacenter_names=["fake_dc1"]
)
self.assertEqual(res, [])
def test_no_parameters(self):
with patch(
"salt.utils.vmware.get_mors_with_properties",
MagicMock(return_value=self.mock_entries),
):
res = salt.utils.vmware.get_datacenters(self.mock_si)
self.assertEqual(res, [])
def test_datastore_not_found(self):
with patch(
"salt.utils.vmware.get_mors_with_properties",
MagicMock(return_value=self.mock_entries),
):
res = salt.utils.vmware.get_datacenters(
self.mock_si, datacenter_names=["fake_dc"]
)
self.assertEqual(res, [])
def test_datastore_found(self):
with patch(
"salt.utils.vmware.get_mors_with_properties",
MagicMock(return_value=self.mock_entries),
):
res = salt.utils.vmware.get_datacenters(
self.mock_si, datacenter_names=["fake_dc2"]
)
self.assertEqual(res, [self.mock_dc2])
def test_get_all_datastores(self):
with patch(
"salt.utils.vmware.get_mors_with_properties",
MagicMock(return_value=self.mock_entries),
):
res = salt.utils.vmware.get_datacenters(
self.mock_si, get_all_datacenters=True
)
self.assertEqual(res, [self.mock_dc1, self.mock_dc2])
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetDatacenterTestCase(TestCase):
"""
Tests for salt.utils.vmware.get_datacenter
"""
def setUp(self):
patches = (
(
"salt.utils.vmware.get_datacenters",
MagicMock(return_value=[MagicMock()]),
),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
self.mock_si = MagicMock()
self.mock_dc = MagicMock()
def test_get_datacenters_call(self):
mock_get_datacenters = MagicMock(return_value=[MagicMock()])
with patch("salt.utils.vmware.get_datacenters", mock_get_datacenters):
salt.utils.vmware.get_datacenter(self.mock_si, "fake_dc1")
mock_get_datacenters.assert_called_once_with(
self.mock_si, datacenter_names=["fake_dc1"]
)
def test_no_datacenters_returned(self):
with patch("salt.utils.vmware.get_datacenters", MagicMock(return_value=[])):
with self.assertRaises(VMwareObjectRetrievalError) as excinfo:
salt.utils.vmware.get_datacenter(self.mock_si, "fake_dc1")
self.assertEqual(
"Datacenter 'fake_dc1' was not found", excinfo.exception.strerror
)
def test_get_datacenter_return(self):
with patch(
"salt.utils.vmware.get_datacenters", MagicMock(return_value=[self.mock_dc])
):
res = salt.utils.vmware.get_datacenter(self.mock_si, "fake_dc1")
self.assertEqual(res, self.mock_dc)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class CreateDatacenterTestCase(TestCase):
"""
Tests for salt.utils.vmware.create_datacenter
"""
def setUp(self):
patches = (("salt.utils.vmware.get_root_folder", MagicMock()),)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
self.mock_si = MagicMock()
self.mock_dc = MagicMock()
self.mock_create_datacenter = MagicMock(return_value=self.mock_dc)
self.mock_root_folder = MagicMock(CreateDatacenter=self.mock_create_datacenter)
def test_get_root_folder(self):
mock_get_root_folder = MagicMock()
with patch("salt.utils.vmware.get_root_folder", mock_get_root_folder):
salt.utils.vmware.create_datacenter(self.mock_si, "fake_dc")
mock_get_root_folder.assert_called_once_with(self.mock_si)
def test_create_datacenter_call(self):
with patch(
"salt.utils.vmware.get_root_folder",
MagicMock(return_value=self.mock_root_folder),
):
salt.utils.vmware.create_datacenter(self.mock_si, "fake_dc")
self.mock_create_datacenter.assert_called_once_with("fake_dc")
def test_create_datacenter_raise_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
self.mock_root_folder = MagicMock(CreateDatacenter=MagicMock(side_effect=exc))
with patch(
"salt.utils.vmware.get_root_folder",
MagicMock(return_value=self.mock_root_folder),
):
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.create_datacenter(self.mock_si, "fake_dc")
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_create_datacenter_raise_vim_fault(self):
exc = vim.VimFault()
exc.msg = "VimFault msg"
self.mock_root_folder = MagicMock(CreateDatacenter=MagicMock(side_effect=exc))
with patch(
"salt.utils.vmware.get_root_folder",
MagicMock(return_value=self.mock_root_folder),
):
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.create_datacenter(self.mock_si, "fake_dc")
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_create_datacenter_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
self.mock_root_folder = MagicMock(CreateDatacenter=MagicMock(side_effect=exc))
with patch(
"salt.utils.vmware.get_root_folder",
MagicMock(return_value=self.mock_root_folder),
):
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.create_datacenter(self.mock_si, "fake_dc")
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_datastore_successfully_created(self):
with patch(
"salt.utils.vmware.get_root_folder",
MagicMock(return_value=self.mock_root_folder),
):
res = salt.utils.vmware.create_datacenter(self.mock_si, "fake_dc")
self.assertEqual(res, self.mock_dc)
class FakeTaskClass:
pass
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
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
):
salt.utils.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,
):
salt.utils.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):
salt.utils.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 = salt.utils.vmware.get_dvss(self.mock_dc_ref)
self.assertEqual(ret, [])
def test_get_all_dvss(self):
ret = salt.utils.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 = salt.utils.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"]]
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
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
):
salt.utils.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,
):
salt.utils.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):
salt.utils.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:
salt.utils.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 = salt.utils.vmware.get_network_folder(self.mock_dc_ref)
self.assertEqual(ret, self.mock_entries[0]["object"])
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
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
):
salt.utils.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
):
salt.utils.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):
salt.utils.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):
salt.utils.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:
salt.utils.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:
salt.utils.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:
salt.utils.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):
salt.utils.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.test_vmware.FakeTaskClass'>".format(
"tests." if RUNTIME_VARS.PYTEST_SESSION else ""
),
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class UpdateDvsTestCase(TestCase):
def setUp(self):
self.mock_task = MagicMock(spec=FakeTaskClass)
self.mock_dvs_ref = MagicMock(
ReconfigureDvs_Task=MagicMock(return_value=self.mock_task)
)
self.mock_dvs_spec = MagicMock()
self.mock_wait_for_task = MagicMock()
patches = (
(
"salt.utils.vmware.get_managed_object_name",
MagicMock(return_value="fake_dvs"),
),
("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_dvs_ref",
"mock_task",
"mock_dvs_spec",
"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
):
salt.utils.vmware.update_dvs(self.mock_dvs_ref, self.mock_dvs_spec)
mock_get_managed_object_name.assert_called_once_with(self.mock_dvs_ref)
def test_reconfigure_dvs_task(self):
salt.utils.vmware.update_dvs(self.mock_dvs_ref, self.mock_dvs_spec)
self.mock_dvs_ref.ReconfigureDvs_Task.assert_called_once_with(
self.mock_dvs_spec
)
def test_reconfigure_dvs_task_raises_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
self.mock_dvs_ref.ReconfigureDvs_Task = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.update_dvs(self.mock_dvs_ref, self.mock_dvs_spec)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_reconfigure_dvs_task_raises_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
self.mock_dvs_ref.ReconfigureDvs_Task = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.update_dvs(self.mock_dvs_ref, self.mock_dvs_spec)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_reconfigure_dvs_task_raises_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
self.mock_dvs_ref.ReconfigureDvs_Task = MagicMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.update_dvs(self.mock_dvs_ref, self.mock_dvs_spec)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_wait_for_tasks(self):
salt.utils.vmware.update_dvs(self.mock_dvs_ref, self.mock_dvs_spec)
self.mock_wait_for_task.assert_called_once_with(
self.mock_task,
"fake_dvs",
"<class '{}unit.utils.test_vmware.FakeTaskClass'>".format(
"tests." if RUNTIME_VARS.PYTEST_SESSION else ""
),
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class SetDvsNetworkResourceManagementEnabledTestCase(TestCase):
def setUp(self):
self.mock_enabled = MagicMock()
self.mock_dvs_ref = MagicMock(EnableNetworkResourceManagement=MagicMock())
patches = (
(
"salt.utils.vmware.get_managed_object_name",
MagicMock(return_value="fake_dvs"),
),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def tearDown(self):
for attr in ("mock_dvs_ref", "mock_enabled"):
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
):
salt.utils.vmware.set_dvs_network_resource_management_enabled(
self.mock_dvs_ref, self.mock_enabled
)
mock_get_managed_object_name.assert_called_once_with(self.mock_dvs_ref)
def test_enable_network_resource_management(self):
salt.utils.vmware.set_dvs_network_resource_management_enabled(
self.mock_dvs_ref, self.mock_enabled
)
self.mock_dvs_ref.EnableNetworkResourceManagement.assert_called_once_with(
enable=self.mock_enabled
)
def test_enable_network_resource_management_raises_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
self.mock_dvs_ref.EnableNetworkResourceManagement = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.set_dvs_network_resource_management_enabled(
self.mock_dvs_ref, self.mock_enabled
)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_enable_network_resource_management_raises_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
self.mock_dvs_ref.EnableNetworkResourceManagement = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.set_dvs_network_resource_management_enabled(
self.mock_dvs_ref, self.mock_enabled
)
def test_enable_network_resource_management_raises_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
self.mock_dvs_ref.EnableNetworkResourceManagement = MagicMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.set_dvs_network_resource_management_enabled(
self.mock_dvs_ref, self.mock_enabled
)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
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:
salt.utils.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
):
salt.utils.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,
):
salt.utils.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,
):
salt.utils.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):
salt.utils.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 = salt.utils.vmware.get_dvportgroups(self.mock_dvs_ref)
self.assertEqual(ret, [])
def test_get_all_pgs(self):
ret = salt.utils.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 = salt.utils.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"]]
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
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
):
salt.utils.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,
):
salt.utils.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):
salt.utils.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:
salt.utils.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 = salt.utils.vmware.get_uplink_dvportgroup(self.mock_dvs_ref)
self.assertEqual(ret, self.mock_items[1]["object"])
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class CreateDvportgroupTestCase(TestCase):
def setUp(self):
self.mock_pg_spec = MagicMock()
self.mock_task = MagicMock(spec=FakeTaskClass)
self.mock_dvs_ref = MagicMock(
CreateDVPortgroup_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_dvs"),
),
("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_spec", "mock_dvs_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
):
salt.utils.vmware.create_dvportgroup(self.mock_dvs_ref, self.mock_pg_spec)
mock_get_managed_object_name.assert_called_once_with(self.mock_dvs_ref)
def test_create_dvporgroup_task(self):
salt.utils.vmware.create_dvportgroup(self.mock_dvs_ref, self.mock_pg_spec)
self.mock_dvs_ref.CreateDVPortgroup_Task.assert_called_once_with(
self.mock_pg_spec
)
def test_create_dvporgroup_task_raises_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
self.mock_dvs_ref.CreateDVPortgroup_Task = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.create_dvportgroup(self.mock_dvs_ref, self.mock_pg_spec)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_create_dvporgroup_task_raises_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
self.mock_dvs_ref.CreateDVPortgroup_Task = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.create_dvportgroup(self.mock_dvs_ref, self.mock_pg_spec)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_create_dvporgroup_task_raises_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
self.mock_dvs_ref.CreateDVPortgroup_Task = MagicMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.create_dvportgroup(self.mock_dvs_ref, self.mock_pg_spec)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_wait_for_tasks(self):
salt.utils.vmware.create_dvportgroup(self.mock_dvs_ref, self.mock_pg_spec)
self.mock_wait_for_task.assert_called_once_with(
self.mock_task,
"fake_dvs",
"<class '{}unit.utils.test_vmware.FakeTaskClass'>".format(
"tests." if RUNTIME_VARS.PYTEST_SESSION else ""
),
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class UpdateDvportgroupTestCase(TestCase):
def setUp(self):
self.mock_pg_spec = MagicMock()
self.mock_task = MagicMock(spec=FakeTaskClass)
self.mock_pg_ref = MagicMock(
ReconfigureDVPortgroup_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_spec", "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
):
salt.utils.vmware.update_dvportgroup(self.mock_pg_ref, self.mock_pg_spec)
mock_get_managed_object_name.assert_called_once_with(self.mock_pg_ref)
def test_reconfigure_dvporgroup_task(self):
salt.utils.vmware.update_dvportgroup(self.mock_pg_ref, self.mock_pg_spec)
self.mock_pg_ref.ReconfigureDVPortgroup_Task.assert_called_once_with(
self.mock_pg_spec
)
def test_reconfigure_dvporgroup_task_raises_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
self.mock_pg_ref.ReconfigureDVPortgroup_Task = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.update_dvportgroup(self.mock_pg_ref, self.mock_pg_spec)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_reconfigure_dvporgroup_task_raises_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
self.mock_pg_ref.ReconfigureDVPortgroup_Task = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.update_dvportgroup(self.mock_pg_ref, self.mock_pg_spec)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_reconfigure_dvporgroup_task_raises_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
self.mock_pg_ref.ReconfigureDVPortgroup_Task = MagicMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.update_dvportgroup(self.mock_pg_ref, self.mock_pg_spec)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_wait_for_tasks(self):
salt.utils.vmware.update_dvportgroup(self.mock_pg_ref, self.mock_pg_spec)
self.mock_wait_for_task.assert_called_once_with(
self.mock_task,
"fake_pg",
"<class '{}unit.utils.test_vmware.FakeTaskClass'>".format(
"tests." if RUNTIME_VARS.PYTEST_SESSION else ""
),
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
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
):
salt.utils.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):
salt.utils.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:
salt.utils.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:
salt.utils.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:
salt.utils.vmware.remove_dvportgroup(self.mock_pg_ref)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_wait_for_tasks(self):
salt.utils.vmware.remove_dvportgroup(self.mock_pg_ref)
self.mock_wait_for_task.assert_called_once_with(
self.mock_task,
"fake_pg",
"<class '{}unit.utils.test_vmware.FakeTaskClass'>".format(
"tests." if RUNTIME_VARS.PYTEST_SESSION else ""
),
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetHostsTestCase(TestCase):
"""
Tests for salt.utils.vmware.get_hosts
"""
def setUp(self):
patches = (
("salt.utils.vmware.get_mors_with_properties", MagicMock(return_value=[])),
("salt.utils.vmware.get_datacenter", MagicMock(return_value=None)),
("salt.utils.vmware.get_cluster", MagicMock(return_value=None)),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
self.mock_root_folder = MagicMock()
self.mock_si = MagicMock()
self.mock_host1, self.mock_host2, self.mock_host3 = (
MagicMock(),
MagicMock(),
MagicMock(),
)
self.mock_prop_host1 = {"name": "fake_hostname1", "object": self.mock_host1}
self.mock_prop_host2 = {"name": "fake_hostname2", "object": self.mock_host2}
self.mock_prop_host3 = {"name": "fake_hostname3", "object": self.mock_host3}
self.mock_prop_hosts = [
self.mock_prop_host1,
self.mock_prop_host2,
self.mock_prop_host3,
]
def test_cluster_no_datacenter(self):
with self.assertRaises(ArgumentValueError) as excinfo:
salt.utils.vmware.get_hosts(self.mock_si, cluster_name="fake_cluster")
self.assertEqual(
excinfo.exception.strerror,
"Must specify the datacenter when specifying the " "cluster",
)
def test_get_si_no_datacenter_no_cluster(self):
mock_get_mors = MagicMock()
mock_get_root_folder = MagicMock(return_value=self.mock_root_folder)
with patch("salt.utils.vmware.get_root_folder", mock_get_root_folder):
with patch("salt.utils.vmware.get_mors_with_properties", mock_get_mors):
salt.utils.vmware.get_hosts(self.mock_si)
mock_get_root_folder.assert_called_once_with(self.mock_si)
mock_get_mors.assert_called_once_with(
self.mock_si,
vim.HostSystem,
container_ref=self.mock_root_folder,
property_list=["name"],
)
def test_get_si_datacenter_name_no_cluster_name(self):
mock_dc = MagicMock()
mock_get_dc = MagicMock(return_value=mock_dc)
mock_get_mors = MagicMock()
with patch("salt.utils.vmware.get_datacenter", mock_get_dc):
with patch("salt.utils.vmware.get_mors_with_properties", mock_get_mors):
salt.utils.vmware.get_hosts(
self.mock_si, datacenter_name="fake_datacenter"
)
mock_get_dc.assert_called_once_with(self.mock_si, "fake_datacenter")
mock_get_mors.assert_called_once_with(
self.mock_si, vim.HostSystem, container_ref=mock_dc, property_list=["name"]
)
def test_get_si_datacenter_name_and_cluster_name(self):
mock_dc = MagicMock()
mock_get_dc = MagicMock(return_value=mock_dc)
mock_get_cl = MagicMock()
mock_get_mors = MagicMock()
with patch("salt.utils.vmware.get_datacenter", mock_get_dc):
with patch("salt.utils.vmware.get_cluster", mock_get_cl):
with patch("salt.utils.vmware.get_mors_with_properties", mock_get_mors):
salt.utils.vmware.get_hosts(
self.mock_si,
datacenter_name="fake_datacenter",
cluster_name="fake_cluster",
)
mock_get_dc.assert_called_once_with(self.mock_si, "fake_datacenter")
mock_get_mors.assert_called_once_with(
self.mock_si,
vim.HostSystem,
container_ref=mock_dc,
property_list=["name", "parent"],
)
def test_host_get_all_hosts(self):
with patch(
"salt.utils.vmware.get_root_folder",
MagicMock(return_value=self.mock_root_folder),
):
with patch(
"salt.utils.vmware.get_mors_with_properties",
MagicMock(return_value=self.mock_prop_hosts),
):
res = salt.utils.vmware.get_hosts(self.mock_si, get_all_hosts=True)
self.assertEqual(res, [self.mock_host1, self.mock_host2, self.mock_host3])
def test_filter_hostname(self):
with patch(
"salt.utils.vmware.get_mors_with_properties",
MagicMock(return_value=self.mock_prop_hosts),
):
res = salt.utils.vmware.get_hosts(
self.mock_si, host_names=["fake_hostname1", "fake_hostname2"]
)
self.assertEqual(res, [self.mock_host1, self.mock_host2])
def test_get_all_host_flag_not_set_and_no_host_names(self):
with patch(
"salt.utils.vmware.get_mors_with_properties",
MagicMock(return_value=self.mock_prop_hosts),
):
res = salt.utils.vmware.get_hosts(self.mock_si)
self.assertEqual(res, [])
def test_filter_cluster(self):
self.mock_prop_host1["parent"] = vim.ClusterComputeResource("cluster")
self.mock_prop_host2["parent"] = vim.ClusterComputeResource("cluster")
self.mock_prop_host3["parent"] = vim.Datacenter("dc")
mock_get_cl_name = MagicMock(
side_effect=["fake_bad_cluster", "fake_good_cluster"]
)
with patch(
"salt.utils.vmware.get_mors_with_properties",
MagicMock(return_value=self.mock_prop_hosts),
):
with patch("salt.utils.vmware.get_managed_object_name", mock_get_cl_name):
res = salt.utils.vmware.get_hosts(
self.mock_si,
datacenter_name="fake_datacenter",
cluster_name="fake_good_cluster",
get_all_hosts=True,
)
self.assertEqual(mock_get_cl_name.call_count, 2)
self.assertEqual(res, [self.mock_host2])
def test_no_hosts(self):
with patch(
"salt.utils.vmware.get_mors_with_properties", MagicMock(return_value=[])
):
res = salt.utils.vmware.get_hosts(self.mock_si, get_all_hosts=True)
self.assertEqual(res, [])
def test_one_host_returned(self):
with patch(
"salt.utils.vmware.get_mors_with_properties",
MagicMock(return_value=[self.mock_prop_host1]),
):
res = salt.utils.vmware.get_hosts(self.mock_si, get_all_hosts=True)
self.assertEqual(res, [self.mock_host1])
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetLicenseManagerTestCase(TestCase):
"""
Tests for salt.utils.vmware.get_license_manager
"""
def setUp(self):
self.mock_si = MagicMock()
self.mock_lic_mgr = MagicMock()
type(self.mock_si.content).licenseManager = PropertyMock(
return_value=self.mock_lic_mgr
)
def tearDown(self):
for attr in ("mock_si", "mock_lic_mgr"):
delattr(self, attr)
def test_raise_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
type(self.mock_si.content).licenseManager = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_license_manager(self.mock_si)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_raise_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
type(self.mock_si.content).licenseManager = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_license_manager(self.mock_si)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
type(self.mock_si.content).licenseManager = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.get_license_manager(self.mock_si)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_valid_assignment_manager(self):
ret = salt.utils.vmware.get_license_manager(self.mock_si)
self.assertEqual(ret, self.mock_lic_mgr)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetLicenseAssignmentManagerTestCase(TestCase):
"""
Tests for salt.utils.vmware.get_license_assignment_manager
"""
def setUp(self):
self.mock_si = MagicMock()
self.mock_lic_assign_mgr = MagicMock()
type(
self.mock_si.content.licenseManager
).licenseAssignmentManager = PropertyMock(return_value=self.mock_lic_assign_mgr)
def tearDown(self):
for attr in ("mock_si", "mock_lic_assign_mgr"):
delattr(self, attr)
def test_raise_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
type(
self.mock_si.content.licenseManager
).licenseAssignmentManager = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_license_assignment_manager(self.mock_si)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_raise_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
type(
self.mock_si.content.licenseManager
).licenseAssignmentManager = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_license_assignment_manager(self.mock_si)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
type(
self.mock_si.content.licenseManager
).licenseAssignmentManager = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.get_license_assignment_manager(self.mock_si)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_empty_license_assignment_manager(self):
type(
self.mock_si.content.licenseManager
).licenseAssignmentManager = PropertyMock(return_value=None)
with self.assertRaises(VMwareObjectRetrievalError) as excinfo:
salt.utils.vmware.get_license_assignment_manager(self.mock_si)
self.assertEqual(
excinfo.exception.strerror, "License assignment manager was not retrieved"
)
def test_valid_assignment_manager(self):
ret = salt.utils.vmware.get_license_assignment_manager(self.mock_si)
self.assertEqual(ret, self.mock_lic_assign_mgr)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetLicensesTestCase(TestCase):
"""
Tests for salt.utils.vmware.get_licenses
"""
def setUp(self):
self.mock_si = MagicMock()
self.mock_licenses = [MagicMock(), MagicMock()]
self.mock_lic_mgr = MagicMock()
type(self.mock_lic_mgr).licenses = PropertyMock(return_value=self.mock_licenses)
patches = (
(
"salt.utils.vmware.get_license_manager",
MagicMock(return_value=self.mock_lic_mgr),
),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def tearDown(self):
for attr in ("mock_si", "mock_lic_mgr", "mock_licenses"):
delattr(self, attr)
def test_no_license_manager_passed_in(self):
mock_get_license_manager = MagicMock()
with patch("salt.utils.vmware.get_license_manager", mock_get_license_manager):
salt.utils.vmware.get_licenses(self.mock_si)
mock_get_license_manager.assert_called_once_with(self.mock_si)
def test_license_manager_passed_in(self):
mock_licenses = PropertyMock()
mock_lic_mgr = MagicMock()
type(mock_lic_mgr).licenses = mock_licenses
mock_get_license_manager = MagicMock()
with patch("salt.utils.vmware.get_license_manager", mock_get_license_manager):
salt.utils.vmware.get_licenses(self.mock_si, license_manager=mock_lic_mgr)
self.assertEqual(mock_get_license_manager.call_count, 0)
self.assertEqual(mock_licenses.call_count, 1)
def test_raise_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
type(self.mock_lic_mgr).licenses = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_licenses(self.mock_si)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_raise_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
type(self.mock_lic_mgr).licenses = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_licenses(self.mock_si)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
type(self.mock_lic_mgr).licenses = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.get_licenses(self.mock_si)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_valid_licenses(self):
ret = salt.utils.vmware.get_licenses(self.mock_si)
self.assertEqual(ret, self.mock_licenses)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class AddLicenseTestCase(TestCase):
"""
Tests for salt.utils.vmware.add_license
"""
def setUp(self):
self.mock_si = MagicMock()
self.mock_license = MagicMock()
self.mock_add_license = MagicMock(return_value=self.mock_license)
self.mock_lic_mgr = MagicMock(AddLicense=self.mock_add_license)
self.mock_label = MagicMock()
patches = (
(
"salt.utils.vmware.get_license_manager",
MagicMock(return_value=self.mock_lic_mgr),
),
("salt.utils.vmware.vim.KeyValue", MagicMock(return_value=self.mock_label)),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def tearDown(self):
for attr in (
"mock_si",
"mock_lic_mgr",
"mock_license",
"mock_add_license",
"mock_label",
):
delattr(self, attr)
def test_no_license_manager_passed_in(self):
mock_get_license_manager = MagicMock()
with patch("salt.utils.vmware.get_license_manager", mock_get_license_manager):
salt.utils.vmware.add_license(
self.mock_si, "fake_license_key", "fake_license_description"
)
mock_get_license_manager.assert_called_once_with(self.mock_si)
def test_license_manager_passed_in(self):
mock_get_license_manager = MagicMock()
with patch("salt.utils.vmware.get_license_manager", mock_get_license_manager):
salt.utils.vmware.add_license(
self.mock_si,
"fake_license_key",
"fake_license_description",
license_manager=self.mock_lic_mgr,
)
self.assertEqual(mock_get_license_manager.call_count, 0)
self.assertEqual(self.mock_add_license.call_count, 1)
def test_label_settings(self):
salt.utils.vmware.add_license(
self.mock_si, "fake_license_key", "fake_license_description"
)
self.assertEqual(self.mock_label.key, "VpxClientLicenseLabel")
self.assertEqual(self.mock_label.value, "fake_license_description")
def test_add_license_arguments(self):
salt.utils.vmware.add_license(
self.mock_si, "fake_license_key", "fake_license_description"
)
self.mock_add_license.assert_called_once_with(
"fake_license_key", [self.mock_label]
)
def test_add_license_raises_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
self.mock_lic_mgr.AddLicense = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.add_license(
self.mock_si, "fake_license_key", "fake_license_description"
)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_add_license_raises_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
self.mock_lic_mgr.AddLicense = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.add_license(
self.mock_si, "fake_license_key", "fake_license_description"
)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_add_license_raises_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
self.mock_lic_mgr.AddLicense = MagicMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.add_license(
self.mock_si, "fake_license_key", "fake_license_description"
)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_valid_license_added(self):
ret = salt.utils.vmware.add_license(
self.mock_si, "fake_license_key", "fake_license_description"
)
self.assertEqual(ret, self.mock_license)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetAssignedLicensesTestCase(TestCase):
"""
Tests for salt.utils.vmware.get_assigned_licenses
"""
def setUp(self):
self.mock_ent_id = MagicMock()
self.mock_si = MagicMock()
type(self.mock_si.content.about).instanceUuid = PropertyMock(
return_value=self.mock_ent_id
)
self.mock_moid = MagicMock()
self.prop_mock_moid = PropertyMock(return_value=self.mock_moid)
self.mock_entity_ref = MagicMock()
type(self.mock_entity_ref)._moId = self.prop_mock_moid
self.mock_assignments = [
MagicMock(entityDisplayName="fake_ent1"),
MagicMock(entityDisplayName="fake_ent2"),
]
self.mock_query_assigned_licenses = MagicMock(
return_value=[
MagicMock(assignedLicense=self.mock_assignments[0]),
MagicMock(assignedLicense=self.mock_assignments[1]),
]
)
self.mock_lic_assign_mgr = MagicMock(
QueryAssignedLicenses=self.mock_query_assigned_licenses
)
patches = (
(
"salt.utils.vmware.get_license_assignment_manager",
MagicMock(return_value=self.mock_lic_assign_mgr),
),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def tearDown(self):
for attr in (
"mock_ent_id",
"mock_si",
"mock_moid",
"prop_mock_moid",
"mock_entity_ref",
"mock_assignments",
"mock_query_assigned_licenses",
"mock_lic_assign_mgr",
):
delattr(self, attr)
def test_no_license_assignment_manager_passed_in(self):
mock_get_license_assign_manager = MagicMock()
with patch(
"salt.utils.vmware.get_license_assignment_manager",
mock_get_license_assign_manager,
):
salt.utils.vmware.get_assigned_licenses(
self.mock_si, self.mock_entity_ref, "fake_entity_name"
)
mock_get_license_assign_manager.assert_called_once_with(self.mock_si)
def test_license_assignment_manager_passed_in(self):
mock_get_license_assign_manager = MagicMock()
with patch(
"salt.utils.vmware.get_license_assignment_manager",
mock_get_license_assign_manager,
):
salt.utils.vmware.get_assigned_licenses(
self.mock_si,
self.mock_entity_ref,
"fake_entity_name",
license_assignment_manager=self.mock_lic_assign_mgr,
)
self.assertEqual(mock_get_license_assign_manager.call_count, 0)
def test_entity_name(self):
mock_trace = MagicMock()
with patch("salt._logging.impl.SaltLoggingClass.trace", mock_trace):
salt.utils.vmware.get_assigned_licenses(
self.mock_si, self.mock_entity_ref, "fake_entity_name"
)
mock_trace.assert_called_once_with(
"Retrieving licenses assigned to '%s'", "fake_entity_name"
)
def test_instance_uuid(self):
mock_instance_uuid_prop = PropertyMock()
type(self.mock_si.content.about).instanceUuid = mock_instance_uuid_prop
self.mock_lic_assign_mgr.QueryAssignedLicenses = MagicMock(
return_value=[MagicMock(entityDisplayName="fake_vcenter")]
)
salt.utils.vmware.get_assigned_licenses(
self.mock_si, entity_name="fake_vcenter"
)
self.assertEqual(mock_instance_uuid_prop.call_count, 1)
def test_instance_uuid_raises_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
type(self.mock_si.content.about).instanceUuid = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_assigned_licenses(
self.mock_si, entity_name="fake_vcenter"
)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_instance_uuid_raises_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
type(self.mock_si.content.about).instanceUuid = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_assigned_licenses(
self.mock_si, entity_name="fake_vcenter"
)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_instance_uuid_raises_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
type(self.mock_si.content.about).instanceUuid = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.get_assigned_licenses(
self.mock_si, entity_name="fake_vcenter"
)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_vcenter_entity_too_many_assignements(self):
self.mock_lic_assign_mgr.QueryAssignedLicenses = MagicMock(
return_value=[MagicMock(), MagicMock()]
)
with self.assertRaises(VMwareObjectRetrievalError) as excinfo:
salt.utils.vmware.get_assigned_licenses(
self.mock_si, entity_name="fake_vcenter"
)
self.assertEqual(
excinfo.exception.strerror,
"Unexpected return. Expect only a single assignment",
)
def test_wrong_vcenter_name(self):
self.mock_lic_assign_mgr.QueryAssignedLicenses = MagicMock(
return_value=[MagicMock(entityDisplayName="bad_vcenter")]
)
with self.assertRaises(VMwareObjectRetrievalError) as excinfo:
salt.utils.vmware.get_assigned_licenses(
self.mock_si, entity_name="fake_vcenter"
)
self.assertEqual(
excinfo.exception.strerror,
"Got license assignment info for a different vcenter",
)
def test_query_assigned_licenses_vcenter(self):
with self.assertRaises(VMwareObjectRetrievalError) as excinfo:
salt.utils.vmware.get_assigned_licenses(
self.mock_si, entity_name="fake_vcenter"
)
self.mock_query_assigned_licenses.assert_called_once_with(self.mock_ent_id)
def test_query_assigned_licenses_with_entity(self):
salt.utils.vmware.get_assigned_licenses(
self.mock_si, self.mock_entity_ref, "fake_entity_name"
)
self.mock_query_assigned_licenses.assert_called_once_with(self.mock_moid)
def test_query_assigned_licenses_raises_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
self.mock_lic_assign_mgr.QueryAssignedLicenses = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_assigned_licenses(
self.mock_si, self.mock_entity_ref, "fake_entity_name"
)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_query_assigned_licenses_raises_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
self.mock_lic_assign_mgr.QueryAssignedLicenses = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.get_assigned_licenses(
self.mock_si, self.mock_entity_ref, "fake_entity_name"
)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_query_assigned_licenses_raises_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
self.mock_lic_assign_mgr.QueryAssignedLicenses = MagicMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.get_assigned_licenses(
self.mock_si, self.mock_entity_ref, "fake_entity_name"
)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_valid_assignments(self):
ret = salt.utils.vmware.get_assigned_licenses(
self.mock_si, self.mock_entity_ref, "fake_entity_name"
)
self.assertEqual(ret, self.mock_assignments)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class AssignLicenseTestCase(TestCase):
"""
Tests for salt.utils.vmware.assign_license
"""
def setUp(self):
self.mock_ent_id = MagicMock()
self.mock_si = MagicMock()
type(self.mock_si.content.about).instanceUuid = PropertyMock(
return_value=self.mock_ent_id
)
self.mock_lic_key = MagicMock()
self.mock_moid = MagicMock()
self.prop_mock_moid = PropertyMock(return_value=self.mock_moid)
self.mock_entity_ref = MagicMock()
type(self.mock_entity_ref)._moId = self.prop_mock_moid
self.mock_license = MagicMock()
self.mock_update_assigned_license = MagicMock(return_value=self.mock_license)
self.mock_lic_assign_mgr = MagicMock(
UpdateAssignedLicense=self.mock_update_assigned_license
)
patches = (
(
"salt.utils.vmware.get_license_assignment_manager",
MagicMock(return_value=self.mock_lic_assign_mgr),
),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def test_no_license_assignment_manager_passed_in(self):
mock_get_license_assign_manager = MagicMock()
with patch(
"salt.utils.vmware.get_license_assignment_manager",
mock_get_license_assign_manager,
):
salt.utils.vmware.assign_license(
self.mock_si,
self.mock_lic_key,
"fake_license_name",
self.mock_entity_ref,
"fake_entity_name",
)
mock_get_license_assign_manager.assert_called_once_with(self.mock_si)
def test_license_assignment_manager_passed_in(self):
mock_get_license_assign_manager = MagicMock()
with patch(
"salt.utils.vmware.get_license_assignment_manager",
mock_get_license_assign_manager,
):
salt.utils.vmware.assign_license(
self.mock_si,
self.mock_lic_key,
"fake_license_name",
self.mock_entity_ref,
"fake_entity_name",
license_assignment_manager=self.mock_lic_assign_mgr,
)
self.assertEqual(mock_get_license_assign_manager.call_count, 0)
self.assertEqual(self.mock_update_assigned_license.call_count, 1)
def test_entity_name(self):
mock_trace = MagicMock()
with patch("salt._logging.impl.SaltLoggingClass.trace", mock_trace):
salt.utils.vmware.assign_license(
self.mock_si,
self.mock_lic_key,
"fake_license_name",
self.mock_entity_ref,
"fake_entity_name",
)
mock_trace.assert_called_once_with(
"Assigning license to '%s'", "fake_entity_name"
)
def test_instance_uuid(self):
mock_instance_uuid_prop = PropertyMock()
type(self.mock_si.content.about).instanceUuid = mock_instance_uuid_prop
self.mock_lic_assign_mgr.UpdateAssignedLicense = MagicMock(
return_value=[MagicMock(entityDisplayName="fake_vcenter")]
)
salt.utils.vmware.assign_license(
self.mock_si,
self.mock_lic_key,
"fake_license_name",
entity_name="fake_entity_name",
)
self.assertEqual(mock_instance_uuid_prop.call_count, 1)
def test_instance_uuid_raises_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
type(self.mock_si.content.about).instanceUuid = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.assign_license(
self.mock_si,
self.mock_lic_key,
"fake_license_name",
entity_name="fake_entity_name",
)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_instance_uuid_raises_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
type(self.mock_si.content.about).instanceUuid = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.assign_license(
self.mock_si,
self.mock_lic_key,
"fake_license_name",
entity_name="fake_entity_name",
)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_instance_uuid_raises_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
type(self.mock_si.content.about).instanceUuid = PropertyMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.assign_license(
self.mock_si,
self.mock_lic_key,
"fake_license_name",
entity_name="fake_entity_name",
)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_update_assigned_licenses_vcenter(self):
salt.utils.vmware.assign_license(
self.mock_si,
self.mock_lic_key,
"fake_license_name",
entity_name="fake_entity_name",
)
self.mock_update_assigned_license.assert_called_once_with(
self.mock_ent_id, self.mock_lic_key, "fake_license_name"
)
def test_update_assigned_licenses_call_with_entity(self):
salt.utils.vmware.assign_license(
self.mock_si,
self.mock_lic_key,
"fake_license_name",
self.mock_entity_ref,
"fake_entity_name",
)
self.mock_update_assigned_license.assert_called_once_with(
self.mock_moid, self.mock_lic_key, "fake_license_name"
)
def test_update_assigned_licenses_raises_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
self.mock_lic_assign_mgr.UpdateAssignedLicense = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.assign_license(
self.mock_si,
self.mock_lic_key,
"fake_license_name",
self.mock_entity_ref,
"fake_entity_name",
)
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_update_assigned_licenses_raises_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = "VimFault msg"
self.mock_lic_assign_mgr.UpdateAssignedLicense = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.assign_license(
self.mock_si,
self.mock_lic_key,
"fake_license_name",
self.mock_entity_ref,
"fake_entity_name",
)
self.assertEqual(excinfo.exception.strerror, "VimFault msg")
def test_update_assigned_licenses_raises_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "RuntimeFault msg"
self.mock_lic_assign_mgr.UpdateAssignedLicense = MagicMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.assign_license(
self.mock_si,
self.mock_lic_key,
"fake_license_name",
self.mock_entity_ref,
"fake_entity_name",
)
self.assertEqual(excinfo.exception.strerror, "RuntimeFault msg")
def test_valid_assignments(self):
ret = salt.utils.vmware.assign_license(
self.mock_si,
self.mock_lic_key,
"fake_license_name",
self.mock_entity_ref,
"fake_entity_name",
)
self.assertEqual(ret, self.mock_license)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetStorageSystemTestCase(TestCase):
"""
Tests for salt.utils.vmware.get_storage_system
"""
def setUp(self):
self.mock_si = MagicMock(content=MagicMock())
self.mock_host_ref = MagicMock()
self.mock_get_managed_object_name = MagicMock(return_value="fake_host")
self.mock_traversal_spec = MagicMock()
self.mock_obj = MagicMock()
self.mock_get_mors = MagicMock(return_value=[{"object": self.mock_obj}])
patches = (
(
"salt.utils.vmware.get_managed_object_name",
self.mock_get_managed_object_name,
),
("salt.utils.vmware.get_mors_with_properties", self.mock_get_mors),
(
"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_host_ref",
"mock_get_managed_object_name",
"mock_traversal_spec",
"mock_obj",
):
delattr(self, attr)
def test_no_hostname_argument(self):
salt.utils.vmware.get_storage_system(self.mock_si, self.mock_host_ref)
self.mock_get_managed_object_name.assert_called_once_with(self.mock_host_ref)
def test_hostname_argument(self):
salt.utils.vmware.get_storage_system(
self.mock_si, self.mock_host_ref, hostname="fake_host"
)
self.assertEqual(self.mock_get_managed_object_name.call_count, 0)
def test_traversal_spec(self):
mock_traversal_spec = MagicMock(return_value=[{"object": self.mock_obj}])
with patch(
"salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec",
mock_traversal_spec,
):
salt.utils.vmware.get_storage_system(self.mock_si, self.mock_host_ref)
mock_traversal_spec.assert_called_once_with(
path="configManager.storageSystem", type=vim.HostSystem, skip=False
)
def test_get_mors_with_properties(self):
salt.utils.vmware.get_storage_system(self.mock_si, self.mock_host_ref)
self.mock_get_mors.assert_called_once_with(
self.mock_si,
vim.HostStorageSystem,
property_list=["systemFile"],
container_ref=self.mock_host_ref,
traversal_spec=self.mock_traversal_spec,
)
def test_empty_mors_result(self):
with patch(
"salt.utils.vmware.get_mors_with_properties", MagicMock(return_value=[])
):
with self.assertRaises(VMwareObjectRetrievalError) as excinfo:
salt.utils.vmware.get_storage_system(self.mock_si, self.mock_host_ref)
self.assertEqual(
excinfo.exception.strerror,
"Host's 'fake_host' storage system was " "not retrieved",
)
def test_valid_mors_result(self):
res = salt.utils.vmware.get_storage_system(self.mock_si, self.mock_host_ref)
self.assertEqual(res, self.mock_obj)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class GetDatastoresTestCase(TestCase):
"""
Tests for salt.utils.vmware.get_datastores
"""
def setUp(self):
self.mock_si = MagicMock()
self.mock_reference = MagicMock(spec=vim.HostSystem)
self.mock_mount_infos = [
MagicMock(
volume=MagicMock(
spec=vim.HostVmfsVolume, extent=[MagicMock(diskName="fake_disk2")]
)
),
MagicMock(
volume=MagicMock(
spec=vim.HostVmfsVolume, extent=[MagicMock(diskName="fake_disk3")]
)
),
]
self.mock_mount_infos[0].volume.name = "fake_ds2"
self.mock_mount_infos[1].volume.name = "fake_ds3"
self.mock_entries = [
{"name": "fake_ds1", "object": MagicMock()},
{"name": "fake_ds2", "object": MagicMock()},
{"name": "fake_ds3", "object": MagicMock()},
]
self.mock_storage_system = MagicMock()
self.mock_get_storage_system = MagicMock(return_value=self.mock_storage_system)
self.mock_get_managed_object_name = MagicMock(return_value="fake_host")
self.mock_traversal_spec = MagicMock()
patches = (
(
"salt.utils.vmware.get_managed_object_name",
self.mock_get_managed_object_name,
),
("salt.utils.vmware.get_storage_system", self.mock_get_storage_system),
(
"salt.utils.vmware.get_properties_of_managed_object",
MagicMock(
return_value={
"fileSystemVolumeInfo.mountInfo": self.mock_mount_infos
}
),
),
(
"salt.utils.vmware.get_mors_with_properties",
MagicMock(return_value=self.mock_entries),
),
(
"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_reference",
"mock_storage_system",
"mock_get_storage_system",
"mock_mount_infos",
"mock_entries",
"mock_get_managed_object_name",
"mock_traversal_spec",
):
delattr(self, attr)
def test_get_reference_name_call(self):
salt.utils.vmware.get_datastores(self.mock_si, self.mock_reference)
self.mock_get_managed_object_name.assert_called_once_with(self.mock_reference)
def test_get_no_datastores(self):
res = salt.utils.vmware.get_datastores(self.mock_si, self.mock_reference)
self.assertEqual(res, [])
def test_get_storage_system_call(self):
salt.utils.vmware.get_datastores(
self.mock_si, self.mock_reference, backing_disk_ids=["fake_disk1"]
)
self.mock_get_storage_system.assert_called_once_with(
self.mock_si, self.mock_reference, "fake_host"
)
def test_get_mount_info_call(self):
mock_get_properties_of_managed_object = MagicMock()
with patch(
"salt.utils.vmware.get_properties_of_managed_object",
mock_get_properties_of_managed_object,
):
salt.utils.vmware.get_datastores(
self.mock_si, self.mock_reference, backing_disk_ids=["fake_disk1"]
)
mock_get_properties_of_managed_object.assert_called_once_with(
self.mock_storage_system, ["fileSystemVolumeInfo.mountInfo"]
)
def test_backing_disks_no_mount_info(self):
with patch(
"salt.utils.vmware.get_properties_of_managed_object",
MagicMock(return_value={}),
):
res = salt.utils.vmware.get_datastores(
self.mock_si, self.mock_reference, backing_disk_ids=["fake_disk_id"]
)
self.assertEqual(res, [])
def test_host_traversal_spec(self):
# Reference is of type vim.HostSystem
mock_traversal_spec_init = MagicMock()
with patch(
"salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec",
mock_traversal_spec_init,
):
salt.utils.vmware.get_datastores(
self.mock_si, self.mock_reference, get_all_datastores=True
)
mock_traversal_spec_init.assert_called_once_with(
name="host_datastore_traversal",
path="datastore",
skip=False,
type=vim.HostSystem,
)
def test_cluster_traversal_spec(self):
mock_traversal_spec_init = MagicMock()
# Reference is of type vim.ClusterComputeResource
mock_reference = MagicMock(spec=vim.ClusterComputeResource)
with patch(
"salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec",
mock_traversal_spec_init,
):
salt.utils.vmware.get_datastores(
self.mock_si, mock_reference, get_all_datastores=True
)
mock_traversal_spec_init.assert_called_once_with(
name="cluster_datastore_traversal",
path="datastore",
skip=False,
type=vim.ClusterComputeResource,
)
def test_datacenter_traversal_spec(self):
mock_traversal_spec_init = MagicMock()
# Reference is of type vim.ClusterComputeResource
mock_reference = MagicMock(spec=vim.Datacenter)
with patch(
"salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec",
mock_traversal_spec_init,
):
salt.utils.vmware.get_datastores(
self.mock_si, mock_reference, get_all_datastores=True
)
mock_traversal_spec_init.assert_called_once_with(
name="datacenter_datastore_traversal",
path="datastore",
skip=False,
type=vim.Datacenter,
)
def test_root_folder_traversal_spec(self):
mock_traversal_spec_init = MagicMock(return_value="traversal")
mock_reference = MagicMock(spec=vim.Folder)
with patch(
"salt.utils.vmware.get_managed_object_name",
MagicMock(side_effect=["fake_host", "Datacenters"]),
):
with patch(
"salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec",
mock_traversal_spec_init,
):
salt.utils.vmware.get_datastores(
self.mock_si, mock_reference, get_all_datastores=True
)
mock_traversal_spec_init.assert_has_calls(
[
call(path="datastore", skip=False, type=vim.Datacenter),
call(
path="childEntity",
selectSet=["traversal"],
skip=False,
type=vim.Folder,
),
]
)
def test_unsupported_reference_type(self):
class FakeClass:
pass
mock_reference = MagicMock(spec=FakeClass)
with self.assertRaises(ArgumentValueError) as excinfo:
salt.utils.vmware.get_datastores(
self.mock_si, mock_reference, get_all_datastores=True
)
self.assertEqual(
excinfo.exception.strerror, "Unsupported reference type 'FakeClass'"
)
def test_get_mors_with_properties(self):
mock_get_mors_with_properties = MagicMock()
with patch(
"salt.utils.vmware.get_mors_with_properties", mock_get_mors_with_properties
):
salt.utils.vmware.get_datastores(
self.mock_si, self.mock_reference, get_all_datastores=True
)
mock_get_mors_with_properties.assert_called_once_with(
self.mock_si,
object_type=vim.Datastore,
property_list=["name"],
container_ref=self.mock_reference,
traversal_spec=self.mock_traversal_spec,
)
def test_get_all_datastores(self):
res = salt.utils.vmware.get_datastores(
self.mock_si, self.mock_reference, get_all_datastores=True
)
self.assertEqual(
res,
[
self.mock_entries[0]["object"],
self.mock_entries[1]["object"],
self.mock_entries[2]["object"],
],
)
def test_get_datastores_filtered_by_name(self):
res = salt.utils.vmware.get_datastores(
self.mock_si, self.mock_reference, datastore_names=["fake_ds1", "fake_ds2"]
)
self.assertEqual(
res, [self.mock_entries[0]["object"], self.mock_entries[1]["object"]]
)
def test_get_datastores_filtered_by_backing_disk(self):
res = salt.utils.vmware.get_datastores(
self.mock_si,
self.mock_reference,
backing_disk_ids=["fake_disk2", "fake_disk3"],
)
self.assertEqual(
res, [self.mock_entries[1]["object"], self.mock_entries[2]["object"]]
)
def test_get_datastores_filtered_by_both_name_and_backing_disk(self):
# Simulate VMware data model for volumes fake_ds2, fake_ds3
res = salt.utils.vmware.get_datastores(
self.mock_si,
self.mock_reference,
datastore_names=["fake_ds1"],
backing_disk_ids=["fake_disk3"],
)
self.assertEqual(
res, [self.mock_entries[0]["object"], self.mock_entries[2]["object"]]
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
class RenameDatastoreTestCase(TestCase):
"""
Tests for salt.utils.vmware.rename_datastore
"""
def setUp(self):
self.mock_ds_ref = MagicMock()
self.mock_get_managed_object_name = MagicMock(return_value="fake_ds")
patches = (
(
"salt.utils.vmware.get_managed_object_name",
self.mock_get_managed_object_name,
),
)
for mod, mock in patches:
patcher = patch(mod, mock)
patcher.start()
self.addCleanup(patcher.stop)
def tearDown(self):
for attr in ("mock_ds_ref", "mock_get_managed_object_name"):
delattr(self, attr)
def test_datastore_name_call(self):
salt.utils.vmware.rename_datastore(self.mock_ds_ref, "fake_new_name")
self.mock_get_managed_object_name.assert_called_once_with(self.mock_ds_ref)
def test_rename_datastore_raise_no_permission(self):
exc = vim.fault.NoPermission()
exc.privilegeId = "Fake privilege"
type(self.mock_ds_ref).RenameDatastore = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.rename_datastore(self.mock_ds_ref, "fake_new_name")
self.assertEqual(
excinfo.exception.strerror,
"Not enough permissions. Required privilege: " "Fake privilege",
)
def test_rename_datastore_raise_vim_fault(self):
exc = vim.VimFault()
exc.msg = "vim_fault"
type(self.mock_ds_ref).RenameDatastore = MagicMock(side_effect=exc)
with self.assertRaises(VMwareApiError) as excinfo:
salt.utils.vmware.rename_datastore(self.mock_ds_ref, "fake_new_name")
self.assertEqual(excinfo.exception.strerror, "vim_fault")
def test_rename_datastore_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = "runtime_fault"
type(self.mock_ds_ref).RenameDatastore = MagicMock(side_effect=exc)
with self.assertRaises(VMwareRuntimeError) as excinfo:
salt.utils.vmware.rename_datastore(self.mock_ds_ref, "fake_new_name")
self.assertEqual(excinfo.exception.strerror, "runtime_fault")
def test_rename_datastore(self):
salt.utils.vmware.rename_datastore(self.mock_ds_ref, "fake_new_name")
self.mock_ds_ref.RenameDatastore.assert_called_once_with("fake_new_name")
class ConvertToKbTestCase(TestCase):
"""
Tests for converting units
"""
def setUp(self):
pass
def test_gb_conversion_call(self):
self.assertEqual(
salt.utils.vmware.convert_to_kb("Gb", 10),
{"size": int(10485760), "unit": "KB"},
)
def test_mb_conversion_call(self):
self.assertEqual(
salt.utils.vmware.convert_to_kb("Mb", 10),
{"size": int(10240), "unit": "KB"},
)
def test_kb_conversion_call(self):
self.assertEqual(
salt.utils.vmware.convert_to_kb("Kb", 10), {"size": int(10), "unit": "KB"}
)
def test_conversion_bad_input_argument_fault(self):
self.assertRaises(
ArgumentValueError, salt.utils.vmware.convert_to_kb, "test", 10
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
@patch("salt.utils.vmware.get_managed_object_name", MagicMock())
@patch("salt.utils.vmware.wait_for_task", MagicMock())
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):
salt.utils.vmware.create_vm(
self.vm_name,
self.mock_config_spec,
self.mock_folder_object,
self.mock_resourcepool_object,
)
self.assert_called_once(self.mock_vm_create_task)
def test_create_vm_host_task_call(self):
salt.utils.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.assert_called_once(self.mock_vm_create_task)
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:
salt.utils.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:
salt.utils.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:
salt.utils.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):
salt.utils.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"
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
@patch("salt.utils.vmware.get_managed_object_name", MagicMock())
@patch("salt.utils.vmware.wait_for_task", MagicMock())
class RegisterVirtualMachineTestCase(TestCase):
"""
Tests for salt.utils.vmware.register_vm
"""
def setUp(self):
self.vm_name = "fake_vm"
self.mock_task = MagicMock()
self.mock_vmx_path = MagicMock()
self.mock_resourcepool_object = MagicMock()
self.mock_host_object = MagicMock()
self.mock_vm_register_task = MagicMock(return_value=self.mock_task)
self.vm_folder_object = MagicMock(RegisterVM_Task=self.mock_vm_register_task)
self.datacenter = MagicMock(vmFolder=self.vm_folder_object)
def test_register_vm_pool_task_call(self):
salt.utils.vmware.register_vm(
self.datacenter,
self.vm_name,
self.mock_vmx_path,
self.mock_resourcepool_object,
)
self.assert_called_once(self.mock_vm_register_task)
def test_register_vm_host_task_call(self):
salt.utils.vmware.register_vm(
self.datacenter,
self.vm_name,
self.mock_vmx_path,
self.mock_resourcepool_object,
host_object=self.mock_host_object,
)
self.assert_called_once(self.mock_vm_register_task)
def test_register_vm_raise_no_permission(self):
exception = vim.fault.NoPermission()
self.vm_folder_object.RegisterVM_Task = MagicMock(side_effect=exception)
with self.assertRaises(VMwareApiError) as exc:
salt.utils.vmware.register_vm(
self.datacenter,
self.vm_name,
self.mock_vmx_path,
self.mock_resourcepool_object,
)
self.assertEqual(
exc.exception.strerror, "Not enough permissions. Required privilege: "
)
def test_register_vm_raise_vim_fault(self):
exception = vim.fault.VimFault()
exception.msg = "vim.fault.VimFault msg"
self.vm_folder_object.RegisterVM_Task = MagicMock(side_effect=exception)
with self.assertRaises(VMwareApiError) as exc:
salt.utils.vmware.register_vm(
self.datacenter,
self.vm_name,
self.mock_vmx_path,
self.mock_resourcepool_object,
)
self.assertEqual(exc.exception.strerror, "vim.fault.VimFault msg")
def test_register_vm_raise_runtime_fault(self):
exception = vmodl.RuntimeFault()
exception.msg = "vmodl.RuntimeFault msg"
self.vm_folder_object.RegisterVM_Task = MagicMock(side_effect=exception)
with self.assertRaises(VMwareRuntimeError) as exc:
salt.utils.vmware.register_vm(
self.datacenter,
self.vm_name,
self.mock_vmx_path,
self.mock_resourcepool_object,
)
self.assertEqual(exc.exception.strerror, "vmodl.RuntimeFault msg")
def test_register_vm_wait_for_task(self):
mock_wait_for_task = MagicMock()
with patch("salt.utils.vmware.wait_for_task", mock_wait_for_task):
salt.utils.vmware.register_vm(
self.datacenter,
self.vm_name,
self.mock_vmx_path,
self.mock_resourcepool_object,
)
mock_wait_for_task.assert_called_once_with(
self.mock_task, self.vm_name, "RegisterVM Task"
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
@patch("salt.utils.vmware.get_managed_object_name", MagicMock())
@patch("salt.utils.vmware.wait_for_task", MagicMock())
class UpdateVirtualMachineTestCase(TestCase):
"""
Tests for salt.utils.vmware.update_vm
"""
def setUp(self):
self.mock_task = MagicMock()
self.mock_config_spec = MagicMock()
self.mock_vm_update_task = MagicMock(return_value=self.mock_task)
self.mock_vm_ref = MagicMock(ReconfigVM_Task=self.mock_vm_update_task)
def test_update_vm_task_call(self):
salt.utils.vmware.update_vm(self.mock_vm_ref, self.mock_config_spec)
self.assert_called_once(self.mock_vm_update_task)
def test_update_vm_raise_vim_fault(self):
exception = vim.fault.VimFault()
exception.msg = "vim.fault.VimFault"
self.mock_vm_ref.ReconfigVM_Task = MagicMock(side_effect=exception)
with self.assertRaises(VMwareApiError) as exc:
salt.utils.vmware.update_vm(self.mock_vm_ref, self.mock_config_spec)
self.assertEqual(exc.exception.strerror, "vim.fault.VimFault")
def test_update_vm_raise_runtime_fault(self):
exception = vmodl.RuntimeFault()
exception.msg = "vmodl.RuntimeFault"
self.mock_vm_ref.ReconfigVM_Task = MagicMock(side_effect=exception)
with self.assertRaises(VMwareRuntimeError) as exc:
salt.utils.vmware.update_vm(self.mock_vm_ref, self.mock_config_spec)
self.assertEqual(exc.exception.strerror, "vmodl.RuntimeFault")
def test_update_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):
salt.utils.vmware.update_vm(self.mock_vm_ref, self.mock_config_spec)
mock_wait_for_task.assert_called_once_with(
self.mock_task, "my_vm", "ReconfigureVM Task"
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
@patch("salt.utils.vmware.get_managed_object_name", MagicMock())
@patch("salt.utils.vmware.wait_for_task", MagicMock())
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):
salt.utils.vmware.delete_vm(self.mock_vm_ref)
self.assert_called_once(self.mock_vm_destroy_task)
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:
salt.utils.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:
salt.utils.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):
salt.utils.vmware.delete_vm(self.mock_vm_ref)
mock_wait_for_task.assert_called_once_with(
self.mock_task, "my_vm", "Destroy Task"
)
@skipIf(not HAS_PYVMOMI, "The 'pyvmomi' library is missing")
@patch("salt.utils.vmware.get_managed_object_name", MagicMock())
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):
salt.utils.vmware.unregister_vm(self.mock_vm_ref)
self.assert_called_once(self.mock_vm_unregister)
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:
salt.utils.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:
salt.utils.vmware.unregister_vm(self.mock_vm_ref)
self.assertEqual(exc.exception.strerror, "vmodl.RuntimeFault")
Reference in a new issue View git blame Copy permalink