# -*- coding: utf-8 -*-
'''
:codeauthor: Alexandru Bleotu <alexandru.bleotu@morganstanley.com>

Tests for cluster related functions in salt.utils.vmware
'''

# Import python libraries
from __future__ import absolute_import, print_function, unicode_literals
import base64
import logging
import ssl
import sys

# Import Salt testing libraries
from tests.support.unit import TestCase, skipIf
from tests.support.mixins import LoaderModuleMockMixin
from tests.support.mock import (
    NO_MOCK,
    NO_MOCK_REASON,
    patch,
    MagicMock,
    PropertyMock,
    call,
)

# Import Salt libraries
from salt.exceptions import (
    ArgumentValueError,
    CommandExecutionError,
    VMwareApiError,
    VMwareConnectionError,
    VMwareRuntimeError,
    VMwareObjectRetrievalError,
    VMwareSystemError,
)
import salt.utils.vmware

# Import Third Party Libs
from salt.ext import six
try:
    from pyVmomi import vim, vmodl
    HAS_PYVMOMI = True
except ImportError:
    HAS_PYVMOMI = False

try:
    import gssapi
    HAS_GSSAPI = True
except ImportError:
    HAS_GSSAPI = False

if sys.version_info[:3] > (2, 7, 8):
    SSL_VALIDATION = True
else:
    SSL_VALIDATION = False

if hasattr(ssl, '_create_unverified_context'):
    ssl_context = 'ssl._create_unverified_context'
else:
    ssl_context = 'ssl._create_stdlib_context'

# Get Logging Started
log = logging.getLogger(__name__)


@skipIf(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(six.text_type(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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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')

    @skipIf(not SSL_VALIDATION, 'SSL validation is not enabled')
    def test_second_attempt_successful_connection(self):
        with patch('ssl.SSLContext', MagicMock()), \
                patch(ssl_context, MagicMock()):
            exc = vim.fault.HostConnectFault()
            exc.msg = '[SSL: CERTIFICATE_VERIFY_FAILED]'
            mock_sc = MagicMock(side_effect=[exc, None])
            mock_ssl = MagicMock()

            with patch('salt.utils.vmware.SmartConnect', mock_sc):
                with patch(ssl_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')

                    mock_ssl.assert_called_once_with()
                    calls = [call(host='fake_host.fqdn',
                                  user='fake_username',
                                  pwd='fake_password',
                                  protocol='fake_protocol',
                                  port=1,
                                  b64token='fake_token',
                                  mechanism='sspi'),
                             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)

    @skipIf(not SSL_VALIDATION, 'SSL validation is not enabled')
    def test_third_attempt_successful_connection(self):
        with patch('ssl.SSLContext', MagicMock()), \
                patch(ssl_context, MagicMock()):
            exc = vim.fault.HostConnectFault()
            exc.msg = '[SSL: CERTIFICATE_VERIFY_FAILED]'
            exc2 = Exception('certificate verify failed')
            mock_sc = MagicMock(side_effect=[exc, exc2, None])
            mock_ssl_unverif = MagicMock()
            mock_ssl_context = MagicMock()

            with patch('salt.utils.vmware.SmartConnect', mock_sc):
                with patch(ssl_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')

                        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,
                                      b64token='fake_token',
                                      mechanism='sspi'),
                                 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_first_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_first_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)

    @skipIf(not SSL_VALIDATION, 'SSL validation is not enabled')
    def test_second_attempt_unsuccsessful_connection_default_error(self):
        with patch('ssl.SSLContext', MagicMock()), \
                patch(ssl_context, MagicMock()):
            exc = vim.fault.HostConnectFault()
            exc.msg = '[SSL: 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')

                    self.assertEqual(mock_sc.call_count, 2)
                    self.assertIn('Could not connect to host \'fake_host.fqdn\'',
                                  excinfo.Exception.message)

    @skipIf(not SSL_VALIDATION, 'SSL validation is not enabled')
    def test_second_attempt_unsuccsessful_connection_vim_fault(self):
        with patch('ssl.SSLContext', MagicMock()), \
                patch(ssl_context, MagicMock()):
            exc = vim.fault.HostConnectFault()
            exc.msg = '[SSL: CERTIFICATE_VERIFY_FAILED]'
            exc2 = vim.fault.VimFault()
            exc2.msg = 'VimFault'
            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')

                    self.assertEqual(mock_sc.call_count, 2)
                    self.assertIn('VimFault', excinfo.Exception.message)

    @skipIf(not SSL_VALIDATION, 'SSL validation is not enabled')
    def test_third_attempt_unsuccessful_connection_detault_error(self):
        with patch('ssl.SSLContext', MagicMock()), \
                patch(ssl_context, MagicMock()):
            exc = vim.fault.HostConnectFault()
            exc.msg = '[SSL: CERTIFICATE_VERIFY_FAILED]'
            exc2 = Exception('certificate verify failed')
            exc3 = Exception('Exception')
            mock_sc = MagicMock(side_effect=[exc, exc2, exc3])

            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, 3)
                    self.assertIn('Exception', excinfo.Exception.message)

    @skipIf(not SSL_VALIDATION, 'SSL validation is not enabled')
    def test_third_attempt_unsuccessful_connection_vim_fault(self):
        with patch('ssl.SSLContext', MagicMock()), \
                patch(ssl_context, MagicMock()):
            exc = vim.fault.HostConnectFault()
            exc.msg = '[SSL: CERTIFICATE_VERIFY_FAILED]'
            exc2 = Exception('certificate verify failed')
            exc3 = vim.fault.VimFault()
            exc3.msg = 'VimFault'
            mock_sc = MagicMock(side_effect=[exc, exc2, exc3])

            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, 3)
                    self.assertIn('VimFault', excinfo.Exception.message)


@skipIf(NO_MOCK, NO_MOCK_REASON)
@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)

    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')

    def test_cached_service_instance_different_host(self):
        mock_si = MagicMock()
        mock_si_stub = 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'
            )
            mock_get_si.assert_called_once_with('fake_host',
                                                'fake_username',
                                                'fake_password',
                                                'fake_protocol',
                                                1,
                                                'fake_mechanism',
                                                'fake_principal',
                                                'fake_domain')

    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_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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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: {
            '__virtual__': MagicMock(return_value='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)

        type(salt.utils.vmware.sys).version_info = \
                PropertyMock(return_value=(2, 7, 9))
        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_ssl_default_context_not_loaded(self):
        type(salt.utils.vmware.sys).version_info = \
                PropertyMock(return_value=(2, 7, 8))
        salt.utils.vmware.get_new_service_instance_stub(
            self.mock_si, 'fake_path')
        self.assertEqual(self.mock_create_default_context.call_count, 0)

    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_get_new_stub_2_7_8_python(self):
        type(salt.utils.vmware.sys).version_info = \
                PropertyMock(return_value=(2, 7, 8))
        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=None)

    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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(object):
    pass


@skipIf(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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\'>')


@skipIf(NO_MOCK, NO_MOCK_REASON)
@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\'>')


@skipIf(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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\'>')


@skipIf(NO_MOCK, NO_MOCK_REASON)
@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\'>')


@skipIf(NO_MOCK, NO_MOCK_REASON)
@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\'>')


@skipIf(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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.log.setup.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(NO_MOCK, NO_MOCK_REASON)
@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.log.setup.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)

    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)

    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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(object):
            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(NO_MOCK, NO_MOCK_REASON)
@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')


@skipIf(NO_MOCK, NO_MOCK_REASON)
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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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(NO_MOCK, NO_MOCK_REASON)
@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')
