mirror of
https://github.com/valitydev/salt.git
synced 2024-11-08 01:18:58 +00:00
Merge pull request #43834 from alexbleotu/tests-gh
Additional tests for functions in salt.modules.vsphere & salt.utils.vsan
This commit is contained in:
Mike Place
GitHub
commit
cbf7acc44d
@ -5672,7 +5672,6 @@ def remove_datastore(datastore, service_instance=None):
|
||||
'''
|
||||
log.trace('Removing datastore \'{0}\''.format(datastore))
|
||||
target = _get_proxy_target(service_instance)
|
||||
taget_name = target.name
|
||||
datastores = salt.utils.vmware.get_datastores(
|
||||
service_instance,
|
||||
reference=target,
|
||||
@ -6340,7 +6339,7 @@ def remove_capacity_from_diskgroup(cache_disk_id, capacity_disk_ids,
|
||||
'capacity_ids': capacity_disk_ids}]},
|
||||
schema)
|
||||
except jsonschema.exceptions.ValidationError as exc:
|
||||
raise ArgumentValueError(exc)
|
||||
raise ArgumentValueError(str(exc))
|
||||
host_ref = _get_proxy_target(service_instance)
|
||||
hostname = __proxy__['esxi.get_details']()['esxi_host']
|
||||
disks = salt.utils.vmware.get_disks(host_ref, disk_ids=capacity_disk_ids)
|
||||
@ -6390,7 +6389,6 @@ def remove_diskgroup(cache_disk_id, data_accessibility=True,
|
||||
salt '*' vsphere.remove_diskgroup cache_disk_id='naa.000000000000001'
|
||||
'''
|
||||
log.trace('Validating diskgroup input')
|
||||
schema = DiskGroupsDiskIdSchema.serialize()
|
||||
host_ref = _get_proxy_target(service_instance)
|
||||
hostname = __proxy__['esxi.get_details']()['esxi_host']
|
||||
diskgroups = \
|
||||
|
||||
@ -1173,6 +1173,437 @@ class CreateDatacenterTestCase(TestCase, LoaderModuleMockMixin):
|
||||
self.assertEqual(res, {'create_datacenter': True})
|
||||
|
||||
|
||||
@skipIf(NO_MOCK, NO_MOCK_REASON)
|
||||
class EraseDiskPartitionsTestCase(TestCase, LoaderModuleMockMixin):
|
||||
'''Tests for salt.modules.vsphere.erase_disk_partitions'''
|
||||
def setup_loader_modules(self):
|
||||
return {
|
||||
vsphere: {
|
||||
'__virtual__': MagicMock(return_value='vsphere'),
|
||||
'_get_proxy_connection_details': MagicMock(),
|
||||
'__proxy__': {'esxi.get_details': MagicMock(
|
||||
return_value={'esxi_host': 'fake_host'})}
|
||||
}
|
||||
}
|
||||
|
||||
def setUp(self):
|
||||
attrs = (('mock_si', MagicMock()),
|
||||
('mock_host', MagicMock()))
|
||||
for attr, mock_obj in attrs:
|
||||
setattr(self, attr, mock_obj)
|
||||
self.addCleanup(delattr, self, attr)
|
||||
attrs = (('mock_proxy_target', MagicMock(return_value=self.mock_host)),
|
||||
('mock_erase_disk_partitions', MagicMock()))
|
||||
for attr, mock_obj in attrs:
|
||||
setattr(self, attr, mock_obj)
|
||||
self.addCleanup(delattr, self, attr)
|
||||
|
||||
patches = (
|
||||
('salt.utils.vmware.get_service_instance',
|
||||
MagicMock(return_value=self.mock_si)),
|
||||
('salt.modules.vsphere.get_proxy_type',
|
||||
MagicMock(return_value='esxi')),
|
||||
('salt.modules.vsphere._get_proxy_target',
|
||||
MagicMock(return_value=self.mock_host)),
|
||||
('salt.utils.vmware.erase_disk_partitions',
|
||||
self.mock_erase_disk_partitions))
|
||||
for module, mock_obj in patches:
|
||||
patcher = patch(module, mock_obj)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def test_supported_proxies(self):
|
||||
supported_proxies = ['esxi']
|
||||
for proxy_type in supported_proxies:
|
||||
with patch('salt.modules.vsphere.get_proxy_type',
|
||||
MagicMock(return_value=proxy_type)):
|
||||
vsphere.erase_disk_partitions(disk_id='fake_disk')
|
||||
|
||||
def test_no_disk_id_or_scsi_address(self):
|
||||
with self.assertRaises(ArgumentValueError) as excinfo:
|
||||
vsphere.erase_disk_partitions()
|
||||
self.assertEqual('Either \'disk_id\' or \'scsi_address\' needs to '
|
||||
'be specified', excinfo.exception.strerror)
|
||||
|
||||
def test_get_proxy_target(self):
|
||||
mock_test_proxy_target = MagicMock()
|
||||
with patch('salt.modules.vsphere._get_proxy_target',
|
||||
mock_test_proxy_target):
|
||||
vsphere.erase_disk_partitions(disk_id='fake_disk')
|
||||
mock_test_proxy_target.assert_called_once_with(self.mock_si)
|
||||
|
||||
def test_scsi_address_not_found(self):
|
||||
mock = MagicMock(return_value={'bad_scsi_address': 'bad_disk_id'})
|
||||
with patch('salt.utils.vmware.get_scsi_address_to_lun_map', mock):
|
||||
with self.assertRaises(VMwareObjectRetrievalError) as excinfo:
|
||||
vsphere.erase_disk_partitions(scsi_address='fake_scsi_address')
|
||||
self.assertEqual('Scsi lun with address \'fake_scsi_address\' was '
|
||||
'not found on host \'fake_host\'',
|
||||
excinfo.exception.strerror)
|
||||
|
||||
def test_scsi_address_to_disk_id_map(self):
|
||||
mock_disk_id = MagicMock(canonicalName='fake_scsi_disk_id')
|
||||
mock_get_scsi_addr_to_lun = \
|
||||
MagicMock(return_value={'fake_scsi_address': mock_disk_id})
|
||||
with patch('salt.utils.vmware.get_scsi_address_to_lun_map',
|
||||
mock_get_scsi_addr_to_lun):
|
||||
vsphere.erase_disk_partitions(scsi_address='fake_scsi_address')
|
||||
mock_get_scsi_addr_to_lun.assert_called_once_with(self.mock_host)
|
||||
self.mock_erase_disk_partitions.assert_called_once_with(
|
||||
self.mock_si, self.mock_host, 'fake_scsi_disk_id',
|
||||
hostname='fake_host')
|
||||
|
||||
def test_erase_disk_partitions(self):
|
||||
vsphere.erase_disk_partitions(disk_id='fake_disk_id')
|
||||
self.mock_erase_disk_partitions.assert_called_once_with(
|
||||
self.mock_si, self.mock_host, 'fake_disk_id', hostname='fake_host')
|
||||
|
||||
|
||||
@skipIf(NO_MOCK, NO_MOCK_REASON)
|
||||
class RemoveDatastoreTestCase(TestCase, LoaderModuleMockMixin):
|
||||
'''Tests for salt.modules.vsphere.remove_datastore'''
|
||||
def setup_loader_modules(self):
|
||||
return {
|
||||
vsphere: {
|
||||
'__virtual__': MagicMock(return_value='vsphere'),
|
||||
'_get_proxy_connection_details': MagicMock(),
|
||||
'get_proxy_type': MagicMock(return_value='esxdatacenter'),
|
||||
}
|
||||
}
|
||||
|
||||
def setUp(self):
|
||||
attrs = (('mock_si', MagicMock()),
|
||||
('mock_target', MagicMock()),
|
||||
('mock_ds', MagicMock()))
|
||||
for attr, mock_obj in attrs:
|
||||
setattr(self, attr, mock_obj)
|
||||
self.addCleanup(delattr, self, attr)
|
||||
|
||||
patches = (
|
||||
('salt.utils.vmware.get_service_instance',
|
||||
MagicMock(return_value=self.mock_si)),
|
||||
('salt.modules.vsphere.get_proxy_type',
|
||||
MagicMock(return_value='esxdatacenter')),
|
||||
('salt.modules.vsphere._get_proxy_target',
|
||||
MagicMock(return_value=self.mock_target)),
|
||||
('salt.utils.vmware.get_datastores',
|
||||
MagicMock(return_value=[self.mock_ds])),
|
||||
('salt.utils.vmware.remove_datastore', MagicMock()))
|
||||
for module, mock_obj in patches:
|
||||
patcher = patch(module, mock_obj)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def test_supported_proxes(self):
|
||||
supported_proxies = ['esxi', 'esxcluster', 'esxdatacenter']
|
||||
for proxy_type in supported_proxies:
|
||||
with patch('salt.modules.vsphere.get_proxy_type',
|
||||
MagicMock(return_value=proxy_type)):
|
||||
vsphere.remove_datastore(datastore='fake_ds_name')
|
||||
|
||||
def test__get_proxy_target_call(self):
|
||||
mock__get_proxy_target = MagicMock(return_value=self.mock_target)
|
||||
with patch('salt.modules.vsphere._get_proxy_target',
|
||||
mock__get_proxy_target):
|
||||
vsphere.remove_datastore(datastore='fake_ds_name')
|
||||
mock__get_proxy_target.assert_called_once_with(self.mock_si)
|
||||
|
||||
def test_get_datastores_call(self):
|
||||
mock_get_datastores = MagicMock()
|
||||
with patch('salt.utils.vmware.get_datastores',
|
||||
mock_get_datastores):
|
||||
vsphere.remove_datastore(datastore='fake_ds')
|
||||
mock_get_datastores.assert_called_once_with(
|
||||
self.mock_si, reference=self.mock_target,
|
||||
datastore_names=['fake_ds'])
|
||||
|
||||
def test_datastore_not_found(self):
|
||||
with patch('salt.utils.vmware.get_datastores',
|
||||
MagicMock(return_value=[])):
|
||||
with self.assertRaises(VMwareObjectRetrievalError) as excinfo:
|
||||
vsphere.remove_datastore(datastore='fake_ds')
|
||||
self.assertEqual('Datastore \'fake_ds\' was not found',
|
||||
excinfo.exception.strerror)
|
||||
|
||||
def test_multiple_datastores_found(self):
|
||||
with patch('salt.utils.vmware.get_datastores',
|
||||
MagicMock(return_value=[MagicMock(), MagicMock()])):
|
||||
with self.assertRaises(VMwareObjectRetrievalError) as excinfo:
|
||||
vsphere.remove_datastore(datastore='fake_ds')
|
||||
self.assertEqual('Multiple datastores \'fake_ds\' were found',
|
||||
excinfo.exception.strerror)
|
||||
|
||||
def test_remove_datastore_call(self):
|
||||
mock_remove_datastore = MagicMock()
|
||||
with patch('salt.utils.vmware.remove_datastore',
|
||||
mock_remove_datastore):
|
||||
vsphere.remove_datastore(datastore='fake_ds')
|
||||
mock_remove_datastore.assert_called_once_with(
|
||||
self.mock_si, self.mock_ds)
|
||||
|
||||
def test_success_output(self):
|
||||
res = vsphere.remove_datastore(datastore='fake_ds')
|
||||
self.assertTrue(res)
|
||||
|
||||
|
||||
@skipIf(NO_MOCK, NO_MOCK_REASON)
|
||||
class RemoveDiskgroupTestCase(TestCase, LoaderModuleMockMixin):
|
||||
'''Tests for salt.modules.vsphere.remove_diskgroup'''
|
||||
def setup_loader_modules(self):
|
||||
return {
|
||||
vsphere: {
|
||||
'__virtual__': MagicMock(return_value='vsphere'),
|
||||
'_get_proxy_connection_details': MagicMock(),
|
||||
'__proxy__': {'esxi.get_details': MagicMock(
|
||||
return_value={'esxi_host': 'fake_host'})}
|
||||
}
|
||||
}
|
||||
|
||||
def setUp(self):
|
||||
attrs = (('mock_si', MagicMock()),
|
||||
('mock_host', MagicMock()),
|
||||
('mock_diskgroup', MagicMock()))
|
||||
for attr, mock_obj in attrs:
|
||||
setattr(self, attr, mock_obj)
|
||||
self.addCleanup(delattr, self, attr)
|
||||
|
||||
patches = (
|
||||
('salt.utils.vmware.get_service_instance',
|
||||
MagicMock(return_value=self.mock_si)),
|
||||
('salt.modules.vsphere.get_proxy_type',
|
||||
MagicMock(return_value='esxi')),
|
||||
('salt.modules.vsphere._get_proxy_target',
|
||||
MagicMock(return_value=self.mock_host)),
|
||||
('salt.utils.vmware.get_diskgroups',
|
||||
MagicMock(return_value=[self.mock_diskgroup])),
|
||||
('salt.utils.vsan.remove_diskgroup', MagicMock()))
|
||||
for module, mock_obj in patches:
|
||||
patcher = patch(module, mock_obj)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def test_supported_proxes(self):
|
||||
supported_proxies = ['esxi']
|
||||
for proxy_type in supported_proxies:
|
||||
with patch('salt.modules.vsphere.get_proxy_type',
|
||||
MagicMock(return_value=proxy_type)):
|
||||
vsphere.remove_diskgroup(cache_disk_id='fake_disk_id')
|
||||
|
||||
def test__get_proxy_target_call(self):
|
||||
mock__get_proxy_target = MagicMock(return_value=self.mock_host)
|
||||
with patch('salt.modules.vsphere._get_proxy_target',
|
||||
mock__get_proxy_target):
|
||||
vsphere.remove_diskgroup(cache_disk_id='fake_disk_id')
|
||||
mock__get_proxy_target.assert_called_once_with(self.mock_si)
|
||||
|
||||
def test_get_disk_groups(self):
|
||||
mock_get_diskgroups = MagicMock(return_value=[self.mock_diskgroup])
|
||||
with patch('salt.utils.vmware.get_diskgroups',
|
||||
mock_get_diskgroups):
|
||||
vsphere.remove_diskgroup(cache_disk_id='fake_disk_id')
|
||||
mock_get_diskgroups.assert_called_once_with(
|
||||
self.mock_host, cache_disk_ids=['fake_disk_id'])
|
||||
|
||||
def test_disk_group_not_found_safety_checks_set(self):
|
||||
with patch('salt.utils.vmware.get_diskgroups',
|
||||
MagicMock(return_value=[])):
|
||||
with self.assertRaises(VMwareObjectRetrievalError) as excinfo:
|
||||
vsphere.remove_diskgroup(cache_disk_id='fake_disk_id')
|
||||
self.assertEqual('No diskgroup with cache disk id '
|
||||
'\'fake_disk_id\' was found in ESXi host '
|
||||
'\'fake_host\'',
|
||||
excinfo.exception.strerror)
|
||||
|
||||
def test_remove_disk_group(self):
|
||||
mock_remove_diskgroup = MagicMock(return_value=None)
|
||||
with patch('salt.utils.vsan.remove_diskgroup',
|
||||
mock_remove_diskgroup):
|
||||
vsphere.remove_diskgroup(cache_disk_id='fake_disk_id')
|
||||
mock_remove_diskgroup.assert_called_once_with(
|
||||
self.mock_si, self.mock_host, self.mock_diskgroup,
|
||||
data_accessibility=True)
|
||||
|
||||
def test_remove_disk_group_data_accessibility_false(self):
|
||||
mock_remove_diskgroup = MagicMock(return_value=None)
|
||||
with patch('salt.utils.vsan.remove_diskgroup',
|
||||
mock_remove_diskgroup):
|
||||
vsphere.remove_diskgroup(cache_disk_id='fake_disk_id',
|
||||
data_accessibility=False)
|
||||
mock_remove_diskgroup.assert_called_once_with(
|
||||
self.mock_si, self.mock_host, self.mock_diskgroup,
|
||||
data_accessibility=False)
|
||||
|
||||
def test_success_output(self):
|
||||
res = vsphere.remove_diskgroup(cache_disk_id='fake_disk_id')
|
||||
self.assertTrue(res)
|
||||
|
||||
|
||||
@skipIf(NO_MOCK, NO_MOCK_REASON)
|
||||
@skipIf(not vsphere.HAS_JSONSCHEMA, 'The \'jsonschema\' library is missing')
|
||||
class RemoveCapacityFromDiskgroupTestCase(TestCase, LoaderModuleMockMixin):
|
||||
'''Tests for salt.modules.vsphere.remove_capacity_from_diskgroup'''
|
||||
def setup_loader_modules(self):
|
||||
return {
|
||||
vsphere: {
|
||||
'__virtual__': MagicMock(return_value='vsphere'),
|
||||
'_get_proxy_connection_details': MagicMock(),
|
||||
'__proxy__': {'esxi.get_details': MagicMock(
|
||||
return_value={'esxi_host': 'fake_host'})}
|
||||
}
|
||||
}
|
||||
|
||||
def setUp(self):
|
||||
attrs = (('mock_si', MagicMock()),
|
||||
('mock_schema', MagicMock()),
|
||||
('mock_host', MagicMock()),
|
||||
('mock_disk1', MagicMock(canonicalName='fake_disk1')),
|
||||
('mock_disk2', MagicMock(canonicalName='fake_disk2')),
|
||||
('mock_disk3', MagicMock(canonicalName='fake_disk3')),
|
||||
('mock_diskgroup', MagicMock()))
|
||||
for attr, mock_obj in attrs:
|
||||
setattr(self, attr, mock_obj)
|
||||
self.addCleanup(delattr, self, attr)
|
||||
|
||||
patches = (
|
||||
('salt.utils.vmware.get_service_instance',
|
||||
MagicMock(return_value=self.mock_si)),
|
||||
('salt.modules.vsphere.DiskGroupsDiskIdSchema.serialize',
|
||||
MagicMock(return_value=self.mock_schema)),
|
||||
('salt.modules.vsphere.jsonschema.validate', MagicMock()),
|
||||
('salt.modules.vsphere.get_proxy_type',
|
||||
MagicMock(return_value='esxi')),
|
||||
('salt.modules.vsphere._get_proxy_target',
|
||||
MagicMock(return_value=self.mock_host)),
|
||||
('salt.utils.vmware.get_disks',
|
||||
MagicMock(return_value=[self.mock_disk1, self.mock_disk2,
|
||||
self.mock_disk3])),
|
||||
('salt.utils.vmware.get_diskgroups',
|
||||
MagicMock(return_value=[self.mock_diskgroup])),
|
||||
('salt.utils.vsan.remove_capacity_from_diskgroup', MagicMock()))
|
||||
for module, mock_obj in patches:
|
||||
patcher = patch(module, mock_obj)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def test_validate(self):
|
||||
mock_schema_validate = MagicMock()
|
||||
with patch('salt.modules.vsphere.jsonschema.validate',
|
||||
mock_schema_validate):
|
||||
vsphere.remove_capacity_from_diskgroup(
|
||||
cache_disk_id='fake_cache_disk_id',
|
||||
capacity_disk_ids=['fake_disk1', 'fake_disk2'])
|
||||
mock_schema_validate.assert_called_once_with(
|
||||
{'diskgroups': [{'cache_id': 'fake_cache_disk_id',
|
||||
'capacity_ids': ['fake_disk1',
|
||||
'fake_disk2']}]},
|
||||
self.mock_schema)
|
||||
|
||||
def test_invalid_schema_validation(self):
|
||||
mock_schema_validate = MagicMock(
|
||||
side_effect=vsphere.jsonschema.exceptions.ValidationError('err'))
|
||||
with patch('salt.modules.vsphere.jsonschema.validate',
|
||||
mock_schema_validate):
|
||||
with self.assertRaises(ArgumentValueError) as excinfo:
|
||||
vsphere.remove_capacity_from_diskgroup(
|
||||
cache_disk_id='fake_cache_disk_id',
|
||||
capacity_disk_ids=['fake_disk1', 'fake_disk2'])
|
||||
self.assertEqual('err', excinfo.exception.strerror)
|
||||
|
||||
def test_supported_proxes(self):
|
||||
supported_proxies = ['esxi']
|
||||
for proxy_type in supported_proxies:
|
||||
with patch('salt.modules.vsphere.get_proxy_type',
|
||||
MagicMock(return_value=proxy_type)):
|
||||
vsphere.remove_capacity_from_diskgroup(
|
||||
cache_disk_id='fake_cache_disk_id',
|
||||
capacity_disk_ids=['fake_disk1', 'fake_disk2'])
|
||||
|
||||
def test__get_proxy_target_call(self):
|
||||
mock__get_proxy_target = MagicMock(return_value=self.mock_host)
|
||||
with patch('salt.modules.vsphere._get_proxy_target',
|
||||
mock__get_proxy_target):
|
||||
vsphere.remove_capacity_from_diskgroup(
|
||||
cache_disk_id='fake_cache_disk_id',
|
||||
capacity_disk_ids=['fake_disk1', 'fake_disk2'])
|
||||
mock__get_proxy_target.assert_called_once_with(self.mock_si)
|
||||
|
||||
def test_get_disks(self):
|
||||
mock_get_disks = MagicMock(
|
||||
return_value=[self.mock_disk1, self.mock_disk2, self.mock_disk3])
|
||||
with patch('salt.utils.vmware.get_disks', mock_get_disks):
|
||||
vsphere.remove_capacity_from_diskgroup(
|
||||
cache_disk_id='fake_cache_disk_id',
|
||||
capacity_disk_ids=['fake_disk1', 'fake_disk2'])
|
||||
mock_get_disks.assert_called_once_with(
|
||||
self.mock_host, disk_ids=['fake_disk1', 'fake_disk2'])
|
||||
|
||||
def test_disk_not_found_safety_checks_set(self):
|
||||
mock_get_disks = MagicMock(
|
||||
return_value=[self.mock_disk1, self.mock_disk2, self.mock_disk3])
|
||||
with patch('salt.utils.vmware.get_disks', mock_get_disks):
|
||||
with self.assertRaises(VMwareObjectRetrievalError) as excinfo:
|
||||
vsphere.remove_capacity_from_diskgroup(
|
||||
cache_disk_id='fake_cache_disk_id',
|
||||
capacity_disk_ids=['fake_disk1', 'fake_disk4'],
|
||||
safety_checks=True)
|
||||
self.assertEqual('No disk with id \'fake_disk4\' was found '
|
||||
'in ESXi host \'fake_host\'',
|
||||
excinfo.exception.strerror)
|
||||
|
||||
def test_get_diskgroups(self):
|
||||
mock_get_diskgroups = MagicMock(return_value=[self.mock_diskgroup])
|
||||
with patch('salt.utils.vmware.get_diskgroups',
|
||||
mock_get_diskgroups):
|
||||
vsphere.remove_capacity_from_diskgroup(
|
||||
cache_disk_id='fake_cache_disk_id',
|
||||
capacity_disk_ids=['fake_disk1', 'fake_disk2'])
|
||||
mock_get_diskgroups.assert_called_once_with(
|
||||
self.mock_host, cache_disk_ids=['fake_cache_disk_id'])
|
||||
|
||||
def test_diskgroup_not_found(self):
|
||||
with patch('salt.utils.vmware.get_diskgroups',
|
||||
MagicMock(return_value=[])):
|
||||
with self.assertRaises(VMwareObjectRetrievalError) as excinfo:
|
||||
vsphere.remove_capacity_from_diskgroup(
|
||||
cache_disk_id='fake_cache_disk_id',
|
||||
capacity_disk_ids=['fake_disk1', 'fake_disk2'])
|
||||
self.assertEqual('No diskgroup with cache disk id '
|
||||
'\'fake_cache_disk_id\' was found in ESXi host '
|
||||
'\'fake_host\'',
|
||||
excinfo.exception.strerror)
|
||||
|
||||
def test_remove_capacity_from_diskgroup(self):
|
||||
mock_remove_capacity_from_diskgroup = MagicMock()
|
||||
with patch('salt.utils.vsan.remove_capacity_from_diskgroup',
|
||||
mock_remove_capacity_from_diskgroup):
|
||||
vsphere.remove_capacity_from_diskgroup(
|
||||
cache_disk_id='fake_cache_disk_id',
|
||||
capacity_disk_ids=['fake_disk1', 'fake_disk2'])
|
||||
mock_remove_capacity_from_diskgroup.assert_called_once_with(
|
||||
self.mock_si, self.mock_host, self.mock_diskgroup,
|
||||
capacity_disks=[self.mock_disk1, self.mock_disk2],
|
||||
data_evacuation=True)
|
||||
|
||||
def test_remove_capacity_from_diskgroup_data_evacuation_false(self):
|
||||
mock_remove_capacity_from_diskgroup = MagicMock()
|
||||
with patch('salt.utils.vsan.remove_capacity_from_diskgroup',
|
||||
mock_remove_capacity_from_diskgroup):
|
||||
vsphere.remove_capacity_from_diskgroup(
|
||||
cache_disk_id='fake_cache_disk_id',
|
||||
capacity_disk_ids=['fake_disk1', 'fake_disk2'],
|
||||
data_evacuation=False)
|
||||
mock_remove_capacity_from_diskgroup.assert_called_once_with(
|
||||
self.mock_si, self.mock_host, self.mock_diskgroup,
|
||||
capacity_disks=[self.mock_disk1, self.mock_disk2],
|
||||
data_evacuation=False)
|
||||
|
||||
def test_success_output(self):
|
||||
res = vsphere.remove_capacity_from_diskgroup(
|
||||
cache_disk_id='fake_cache_disk_id',
|
||||
capacity_disk_ids=['fake_disk1', 'fake_disk2'])
|
||||
self.assertTrue(res)
|
||||
|
||||
|
||||
@skipIf(NO_MOCK, NO_MOCK_REASON)
|
||||
class ListClusterTestCase(TestCase, LoaderModuleMockMixin):
|
||||
'''Tests for salt.modules.vsphere.list_cluster'''
|
||||
|
||||
@ -16,7 +16,8 @@ from tests.support.mock import NO_MOCK, NO_MOCK_REASON, patch, MagicMock, \
|
||||
PropertyMock
|
||||
|
||||
# Import Salt libraries
|
||||
from salt.exceptions import VMwareApiError, VMwareRuntimeError
|
||||
from salt.exceptions import VMwareApiError, VMwareRuntimeError, \
|
||||
VMwareObjectRetrievalError
|
||||
from salt.utils import vsan
|
||||
|
||||
try:
|
||||
@ -137,6 +138,651 @@ class GetVsanClusterConfigSystemTestCase(TestCase, LoaderModuleMockMixin):
|
||||
self.assertEqual(ret, self.mock_ret)
|
||||
|
||||
|
||||
@skipIf(NO_MOCK, NO_MOCK_REASON)
|
||||
@skipIf(not HAS_PYVMOMI, 'The \'pyvmomi\' library is missing')
|
||||
@skipIf(not HAS_PYVSAN, 'The \'pyvsan\' bindings are missing')
|
||||
class GetVsanDiskManagementSystemTestCase(TestCase, LoaderModuleMockMixin):
|
||||
'''Tests for salt.utils.vsan.get_vsan_disk_management_system'''
|
||||
def setup_loader_modules(self):
|
||||
return {vsan: {
|
||||
'__virtual__': MagicMock(return_value='vsan'),
|
||||
'sys': MagicMock(),
|
||||
'ssl': MagicMock()}}
|
||||
|
||||
def setUp(self):
|
||||
self.mock_si = MagicMock()
|
||||
self.mock_ret = MagicMock()
|
||||
patches = (('salt.utils.vsan.vsanapiutils.GetVsanVcMos',
|
||||
MagicMock(
|
||||
return_value={'vsan-disk-management-system':
|
||||
self.mock_ret})),)
|
||||
for mod, mock in patches:
|
||||
patcher = patch(mod, mock)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
type(vsan.sys).version_info = PropertyMock(return_value=(2, 7, 9))
|
||||
self.mock_context = MagicMock()
|
||||
self.mock_create_default_context = \
|
||||
MagicMock(return_value=self.mock_context)
|
||||
vsan.ssl.create_default_context = self.mock_create_default_context
|
||||
|
||||
def tearDown(self):
|
||||
for attr in ('mock_si', 'mock_ret', 'mock_context',
|
||||
'mock_create_default_context'):
|
||||
delattr(self, attr)
|
||||
|
||||
def test_ssl_default_context_loaded(self):
|
||||
vsan.get_vsan_disk_management_system(self.mock_si)
|
||||
self.mock_create_default_context.assert_called_once_with()
|
||||
self.assertFalse(self.mock_context.check_hostname)
|
||||
self.assertEqual(self.mock_context.verify_mode, vsan.ssl.CERT_NONE)
|
||||
|
||||
def test_ssl_default_context_not_loaded(self):
|
||||
type(vsan.sys).version_info = PropertyMock(return_value=(2, 7, 8))
|
||||
vsan.get_vsan_disk_management_system(self.mock_si)
|
||||
self.assertEqual(self.mock_create_default_context.call_count, 0)
|
||||
|
||||
def test_GetVsanVcMos_call(self):
|
||||
mock_get_vsan_vc_mos = MagicMock()
|
||||
with patch('salt.utils.vsan.vsanapiutils.GetVsanVcMos',
|
||||
mock_get_vsan_vc_mos):
|
||||
vsan.get_vsan_disk_management_system(self.mock_si)
|
||||
mock_get_vsan_vc_mos.assert_called_once_with(self.mock_si._stub,
|
||||
context=self.mock_context)
|
||||
|
||||
def test_return(self):
|
||||
ret = vsan.get_vsan_disk_management_system(self.mock_si)
|
||||
self.assertEqual(ret, self.mock_ret)
|
||||
|
||||
|
||||
@skipIf(NO_MOCK, NO_MOCK_REASON)
|
||||
@skipIf(not HAS_PYVMOMI, 'The \'pyvmomi\' library is missing')
|
||||
@skipIf(not HAS_PYVSAN, 'The \'vsan\' ext library is missing')
|
||||
class GetHostVsanSystemTestCase(TestCase):
|
||||
'''Tests for salt.utils.vsan.get_host_vsan_system'''
|
||||
|
||||
def setUp(self):
|
||||
self.mock_host_ref = MagicMock()
|
||||
self.mock_si = MagicMock()
|
||||
self.mock_traversal_spec = MagicMock()
|
||||
self.mock_vsan_system = MagicMock()
|
||||
patches = (
|
||||
('salt.utils.vmware.get_managed_object_name',
|
||||
MagicMock(return_value='fake_hostname')),
|
||||
('salt.utils.vsan.vmodl.query.PropertyCollector.TraversalSpec',
|
||||
MagicMock(return_value=self.mock_traversal_spec)),
|
||||
('salt.utils.vmware.get_mors_with_properties',
|
||||
MagicMock(return_value=self.mock_traversal_spec)),
|
||||
('salt.utils.vmware.get_mors_with_properties',
|
||||
MagicMock(return_value=[{'object': self.mock_vsan_system}])))
|
||||
for mod, mock in patches:
|
||||
patcher = patch(mod, mock)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def test_get_hostname(self):
|
||||
mock_get_managed_object_name = MagicMock(return_value='fake_hostname')
|
||||
with patch('salt.utils.vmware.get_managed_object_name',
|
||||
mock_get_managed_object_name):
|
||||
vsan.get_host_vsan_system(self.mock_si, self.mock_host_ref)
|
||||
mock_get_managed_object_name.assert_called_once_with(
|
||||
self.mock_host_ref)
|
||||
|
||||
def test_hostname_argument(self):
|
||||
mock_get_managed_object_name = MagicMock(return_value='fake_hostname')
|
||||
with patch('salt.utils.vmware.get_managed_object_name',
|
||||
MagicMock(return_value='fake_hostname')):
|
||||
vsan.get_host_vsan_system(self.mock_si,
|
||||
self.mock_host_ref,
|
||||
hostname='passedin_hostname')
|
||||
self.assertEqual(mock_get_managed_object_name.call_count, 0)
|
||||
|
||||
def test_traversal_spec(self):
|
||||
mock_traversal_spec = MagicMock(return_value=self.mock_traversal_spec)
|
||||
with patch(
|
||||
'salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec',
|
||||
mock_traversal_spec):
|
||||
|
||||
vsan.get_host_vsan_system(self.mock_si, self.mock_host_ref)
|
||||
mock_traversal_spec.assert_called_once_with(
|
||||
path='configManager.vsanSystem',
|
||||
type=vim.HostSystem,
|
||||
skip=False)
|
||||
|
||||
def test_get_mors_with_properties(self):
|
||||
mock_get_mors = \
|
||||
MagicMock(return_value=[{'object': self.mock_vsan_system}])
|
||||
with patch('salt.utils.vmware.get_mors_with_properties',
|
||||
mock_get_mors):
|
||||
vsan.get_host_vsan_system(self.mock_si, self.mock_host_ref)
|
||||
mock_get_mors.assert_called_once_with(
|
||||
self.mock_si,
|
||||
vim.HostVsanSystem,
|
||||
property_list=['config.enabled'],
|
||||
container_ref=self.mock_host_ref,
|
||||
traversal_spec=self.mock_traversal_spec)
|
||||
|
||||
def test_empty_mors_result(self):
|
||||
mock_get_mors = MagicMock(return_value=None)
|
||||
with patch('salt.utils.vmware.get_mors_with_properties',
|
||||
mock_get_mors):
|
||||
|
||||
with self.assertRaises(VMwareObjectRetrievalError) as excinfo:
|
||||
vsan.get_host_vsan_system(self.mock_si, self.mock_host_ref)
|
||||
self.assertEqual(excinfo.exception.strerror,
|
||||
'Host\'s \'fake_hostname\' VSAN system was '
|
||||
'not retrieved')
|
||||
|
||||
def test_valid_mors_result(self):
|
||||
res = vsan.get_host_vsan_system(self.mock_si, self.mock_host_ref)
|
||||
self.assertEqual(res, self.mock_vsan_system)
|
||||
|
||||
|
||||
@skipIf(NO_MOCK, NO_MOCK_REASON)
|
||||
@skipIf(not HAS_PYVMOMI, 'The \'pyvmomi\' library is missing')
|
||||
@skipIf(not HAS_PYVSAN, 'The \'vsan\' ext library is missing')
|
||||
class CreateDiskgroupTestCase(TestCase):
|
||||
'''Tests for salt.utils.vsan.create_diskgroup'''
|
||||
def setUp(self):
|
||||
self.mock_si = MagicMock()
|
||||
self.mock_task = MagicMock()
|
||||
self.mock_initialise_disk_mapping = \
|
||||
MagicMock(return_value=self.mock_task)
|
||||
self.mock_vsan_disk_mgmt_system = MagicMock(
|
||||
InitializeDiskMappings=self.mock_initialise_disk_mapping)
|
||||
self.mock_host_ref = MagicMock()
|
||||
self.mock_cache_disk = MagicMock()
|
||||
self.mock_cap_disk1 = MagicMock()
|
||||
self.mock_cap_disk2 = MagicMock()
|
||||
self.mock_spec = MagicMock()
|
||||
patches = (
|
||||
('salt.utils.vmware.get_managed_object_name',
|
||||
MagicMock(return_value='fake_hostname')),
|
||||
('salt.utils.vsan.vim.VimVsanHostDiskMappingCreationSpec',
|
||||
MagicMock(return_value=self.mock_spec)),
|
||||
('salt.utils.vsan._wait_for_tasks', MagicMock()))
|
||||
for mod, mock in patches:
|
||||
patcher = patch(mod, mock)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def test_get_hostname(self):
|
||||
mock_get_managed_object_name = MagicMock(return_value='fake_hostname')
|
||||
with patch('salt.utils.vmware.get_managed_object_name',
|
||||
mock_get_managed_object_name):
|
||||
vsan.create_diskgroup(self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_cache_disk,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
mock_get_managed_object_name.assert_called_once_with(
|
||||
self.mock_host_ref)
|
||||
|
||||
def test_vsan_spec_all_flash(self):
|
||||
self.mock_cap_disk1.ssd = True
|
||||
vsan.create_diskgroup(self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_cache_disk,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.assertEqual(self.mock_spec.capacityDisks, [self.mock_cap_disk1,
|
||||
self.mock_cap_disk2])
|
||||
self.assertEqual(self.mock_spec.cacheDisks, [self.mock_cache_disk])
|
||||
self.assertEqual(self.mock_spec.creationType, 'allFlash')
|
||||
self.assertEqual(self.mock_spec.host, self.mock_host_ref)
|
||||
|
||||
def test_vsan_spec_hybrid(self):
|
||||
self.mock_cap_disk1.ssd = False
|
||||
vsan.create_diskgroup(self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_cache_disk,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.mock_cap_disk1.ssd = False
|
||||
self.assertEqual(self.mock_spec.creationType, 'hybrid')
|
||||
|
||||
def test_initialize_disk_mapping(self):
|
||||
vsan.create_diskgroup(self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_cache_disk,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.mock_initialise_disk_mapping.assert_called_once_with(
|
||||
self.mock_spec)
|
||||
|
||||
def test_initialize_disk_mapping_raise_no_permission(self):
|
||||
err = vim.fault.NoPermission()
|
||||
err.privilegeId = 'Fake privilege'
|
||||
self.mock_vsan_disk_mgmt_system.InitializeDiskMappings = \
|
||||
MagicMock(side_effect=err)
|
||||
with self.assertRaises(VMwareApiError) as excinfo:
|
||||
vsan.create_diskgroup(self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_cache_disk,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.assertEqual(excinfo.exception.strerror,
|
||||
'Not enough permissions. Required privilege: '
|
||||
'Fake privilege')
|
||||
|
||||
def test_initialize_disk_mapping_raise_vim_fault(self):
|
||||
err = vim.fault.VimFault()
|
||||
err.msg = 'vim_fault'
|
||||
self.mock_vsan_disk_mgmt_system.InitializeDiskMappings = \
|
||||
MagicMock(side_effect=err)
|
||||
with self.assertRaises(VMwareApiError) as excinfo:
|
||||
vsan.create_diskgroup(self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_cache_disk,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.assertEqual(excinfo.exception.strerror, 'vim_fault')
|
||||
|
||||
def test_initialize_disk_mapping_raise_method_not_found(self):
|
||||
err = vmodl.fault.MethodNotFound()
|
||||
err.method = 'fake_method'
|
||||
self.mock_vsan_disk_mgmt_system.InitializeDiskMappings = \
|
||||
MagicMock(side_effect=err)
|
||||
with self.assertRaises(VMwareRuntimeError) as excinfo:
|
||||
vsan.create_diskgroup(self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_cache_disk,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.assertEqual(excinfo.exception.strerror,
|
||||
'Method \'fake_method\' not found')
|
||||
|
||||
def test_initialize_disk_mapping_raise_runtime_fault(self):
|
||||
err = vmodl.RuntimeFault()
|
||||
err.msg = 'runtime_fault'
|
||||
self.mock_vsan_disk_mgmt_system.InitializeDiskMappings = \
|
||||
MagicMock(side_effect=err)
|
||||
with self.assertRaises(VMwareRuntimeError) as excinfo:
|
||||
vsan.create_diskgroup(self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_cache_disk,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.assertEqual(excinfo.exception.strerror, 'runtime_fault')
|
||||
|
||||
def test__wait_for_tasks(self):
|
||||
mock___wait_for_tasks = MagicMock()
|
||||
with patch('salt.utils.vsan._wait_for_tasks',
|
||||
mock___wait_for_tasks):
|
||||
vsan.create_diskgroup(self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_cache_disk,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
mock___wait_for_tasks.assert_called_once_with(
|
||||
[self.mock_task], self.mock_si)
|
||||
|
||||
def test_result(self):
|
||||
res = vsan.create_diskgroup(self.mock_si,
|
||||
self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_cache_disk,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.assertTrue(res)
|
||||
|
||||
|
||||
@skipIf(NO_MOCK, NO_MOCK_REASON)
|
||||
@skipIf(not HAS_PYVMOMI, 'The \'pyvmomi\' library is missing')
|
||||
@skipIf(not HAS_PYVSAN, 'The \'vsan\' ext library is missing')
|
||||
class AddCapacityToDiskGroupTestCase(TestCase):
|
||||
'''Tests for salt.utils.vsan.add_capacity_to_diskgroup'''
|
||||
def setUp(self):
|
||||
self.mock_si = MagicMock()
|
||||
self.mock_task = MagicMock()
|
||||
self.mock_initialise_disk_mapping = \
|
||||
MagicMock(return_value=self.mock_task)
|
||||
self.mock_vsan_disk_mgmt_system = MagicMock(
|
||||
InitializeDiskMappings=self.mock_initialise_disk_mapping)
|
||||
self.mock_host_ref = MagicMock()
|
||||
self.mock_cache_disk = MagicMock()
|
||||
self.mock_diskgroup = MagicMock(ssd=self.mock_cache_disk)
|
||||
self.mock_cap_disk1 = MagicMock()
|
||||
self.mock_cap_disk2 = MagicMock()
|
||||
self.mock_spec = MagicMock()
|
||||
patches = (
|
||||
('salt.utils.vmware.get_managed_object_name',
|
||||
MagicMock(return_value='fake_hostname')),
|
||||
('salt.utils.vsan.vim.VimVsanHostDiskMappingCreationSpec',
|
||||
MagicMock(return_value=self.mock_spec)),
|
||||
('salt.utils.vsan._wait_for_tasks', MagicMock()))
|
||||
for mod, mock in patches:
|
||||
patcher = patch(mod, mock)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def test_get_hostname(self):
|
||||
mock_get_managed_object_name = MagicMock(return_value='fake_hostname')
|
||||
with patch('salt.utils.vmware.get_managed_object_name',
|
||||
mock_get_managed_object_name):
|
||||
vsan.add_capacity_to_diskgroup(
|
||||
self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
mock_get_managed_object_name.assert_called_once_with(
|
||||
self.mock_host_ref)
|
||||
|
||||
def test_vsan_spec_all_flash(self):
|
||||
self.mock_cap_disk1.ssd = True
|
||||
vsan.add_capacity_to_diskgroup(
|
||||
self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.assertEqual(self.mock_spec.capacityDisks, [self.mock_cap_disk1,
|
||||
self.mock_cap_disk2])
|
||||
self.assertEqual(self.mock_spec.cacheDisks, [self.mock_cache_disk])
|
||||
self.assertEqual(self.mock_spec.creationType, 'allFlash')
|
||||
self.assertEqual(self.mock_spec.host, self.mock_host_ref)
|
||||
|
||||
def test_vsan_spec_hybrid(self):
|
||||
self.mock_cap_disk1.ssd = False
|
||||
vsan.add_capacity_to_diskgroup(
|
||||
self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.mock_cap_disk1.ssd = False
|
||||
self.assertEqual(self.mock_spec.creationType, 'hybrid')
|
||||
|
||||
def test_initialize_disk_mapping(self):
|
||||
vsan.add_capacity_to_diskgroup(
|
||||
self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.mock_initialise_disk_mapping.assert_called_once_with(
|
||||
self.mock_spec)
|
||||
|
||||
def test_initialize_disk_mapping_raise_no_permission(self):
|
||||
err = vim.fault.NoPermission()
|
||||
err.privilegeId = 'Fake privilege'
|
||||
self.mock_vsan_disk_mgmt_system.InitializeDiskMappings = \
|
||||
MagicMock(side_effect=err)
|
||||
with self.assertRaises(VMwareApiError) as excinfo:
|
||||
vsan.add_capacity_to_diskgroup(
|
||||
self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.assertEqual(excinfo.exception.strerror,
|
||||
'Not enough permissions. Required privilege: '
|
||||
'Fake privilege')
|
||||
|
||||
def test_initialize_disk_mapping_raise_vim_fault(self):
|
||||
err = vim.fault.VimFault()
|
||||
err.msg = 'vim_fault'
|
||||
self.mock_vsan_disk_mgmt_system.InitializeDiskMappings = \
|
||||
MagicMock(side_effect=err)
|
||||
with self.assertRaises(VMwareApiError) as excinfo:
|
||||
vsan.add_capacity_to_diskgroup(
|
||||
self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.assertEqual(excinfo.exception.strerror, 'vim_fault')
|
||||
|
||||
def test_initialize_disk_mapping_raise_method_not_found(self):
|
||||
err = vmodl.fault.MethodNotFound()
|
||||
err.method = 'fake_method'
|
||||
self.mock_vsan_disk_mgmt_system.InitializeDiskMappings = \
|
||||
MagicMock(side_effect=err)
|
||||
with self.assertRaises(VMwareRuntimeError) as excinfo:
|
||||
vsan.add_capacity_to_diskgroup(
|
||||
self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.assertEqual(excinfo.exception.strerror,
|
||||
'Method \'fake_method\' not found')
|
||||
|
||||
def test_initialize_disk_mapping_raise_runtime_fault(self):
|
||||
err = vmodl.RuntimeFault()
|
||||
err.msg = 'runtime_fault'
|
||||
self.mock_vsan_disk_mgmt_system.InitializeDiskMappings = \
|
||||
MagicMock(side_effect=err)
|
||||
with self.assertRaises(VMwareRuntimeError) as excinfo:
|
||||
vsan.add_capacity_to_diskgroup(
|
||||
self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.assertEqual(excinfo.exception.strerror, 'runtime_fault')
|
||||
|
||||
def test__wait_for_tasks(self):
|
||||
mock___wait_for_tasks = MagicMock()
|
||||
with patch('salt.utils.vsan._wait_for_tasks',
|
||||
mock___wait_for_tasks):
|
||||
vsan.add_capacity_to_diskgroup(
|
||||
self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
mock___wait_for_tasks.assert_called_once_with(
|
||||
[self.mock_task], self.mock_si)
|
||||
|
||||
def test_result(self):
|
||||
res = vsan.add_capacity_to_diskgroup(
|
||||
self.mock_si, self.mock_vsan_disk_mgmt_system,
|
||||
self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.assertTrue(res)
|
||||
|
||||
|
||||
@skipIf(NO_MOCK, NO_MOCK_REASON)
|
||||
@skipIf(not HAS_PYVMOMI, 'The \'pyvmomi\' library is missing')
|
||||
@skipIf(not HAS_PYVSAN, 'The \'vsan\' ext library is missing')
|
||||
class RemoveCapacityFromDiskGroup(TestCase):
|
||||
'''Tests for salt.utils.vsan.remove_capacity_from_diskgroup'''
|
||||
def setUp(self):
|
||||
self.mock_si = MagicMock()
|
||||
self.mock_task = MagicMock()
|
||||
self.mock_remove_disk = \
|
||||
MagicMock(return_value=self.mock_task)
|
||||
self.mock_host_vsan_system = MagicMock(
|
||||
RemoveDisk_Task=self.mock_remove_disk)
|
||||
self.mock_host_ref = MagicMock()
|
||||
self.mock_cache_disk = MagicMock()
|
||||
self.mock_diskgroup = MagicMock(ssd=self.mock_cache_disk)
|
||||
self.mock_cap_disk1 = MagicMock()
|
||||
self.mock_cap_disk2 = MagicMock()
|
||||
self.mock_spec = MagicMock()
|
||||
patches = (
|
||||
('salt.utils.vmware.get_managed_object_name',
|
||||
MagicMock(return_value='fake_hostname')),
|
||||
('salt.utils.vsan.get_host_vsan_system',
|
||||
MagicMock(return_value=self.mock_host_vsan_system)),
|
||||
('salt.utils.vsan.vim.HostMaintenanceSpec',
|
||||
MagicMock(return_value=self.mock_spec)),
|
||||
('salt.utils.vsan.vim.VsanHostDecommissionMode', MagicMock()),
|
||||
('salt.utils.vmware.wait_for_task', MagicMock()))
|
||||
for mod, mock in patches:
|
||||
patcher = patch(mod, mock)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def test_get_hostname(self):
|
||||
mock_get_managed_object_name = MagicMock(return_value='fake_hostname')
|
||||
with patch('salt.utils.vmware.get_managed_object_name',
|
||||
mock_get_managed_object_name):
|
||||
vsan.remove_capacity_from_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
mock_get_managed_object_name.assert_called_once_with(
|
||||
self.mock_host_ref)
|
||||
|
||||
def test_maintenance_mode_evacuate_all_data(self):
|
||||
vsan.remove_capacity_from_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.assertEqual(self.mock_spec.vsanMode.objectAction,
|
||||
vim.VsanHostDecommissionModeObjectAction.evacuateAllData)
|
||||
|
||||
def test_maintenance_mode_no_action(self):
|
||||
vsan.remove_capacity_from_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2],
|
||||
data_evacuation=False)
|
||||
self.assertEqual(self.mock_spec.vsanMode.objectAction,
|
||||
vim.VsanHostDecommissionModeObjectAction.noAction)
|
||||
|
||||
def test_remove_disk(self):
|
||||
vsan.remove_capacity_from_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.mock_remove_disk.assert_called_once_with(
|
||||
disk=[self.mock_cap_disk1, self.mock_cap_disk2],
|
||||
maintenanceSpec=self.mock_spec)
|
||||
|
||||
def test_remove_disk_raise_no_permission(self):
|
||||
err = vim.fault.NoPermission()
|
||||
err.privilegeId = 'Fake privilege'
|
||||
self.mock_host_vsan_system.RemoveDisk_Task = \
|
||||
MagicMock(side_effect=err)
|
||||
with self.assertRaises(VMwareApiError) as excinfo:
|
||||
vsan.remove_capacity_from_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.assertEqual(excinfo.exception.strerror,
|
||||
'Not enough permissions. Required privilege: '
|
||||
'Fake privilege')
|
||||
|
||||
def test_remove_disk_raise_vim_fault(self):
|
||||
err = vim.fault.VimFault()
|
||||
err.msg = 'vim_fault'
|
||||
self.mock_host_vsan_system.RemoveDisk_Task = \
|
||||
MagicMock(side_effect=err)
|
||||
with self.assertRaises(VMwareApiError) as excinfo:
|
||||
vsan.remove_capacity_from_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.assertEqual(excinfo.exception.strerror, 'vim_fault')
|
||||
|
||||
def test_remove_disk_raise_runtime_fault(self):
|
||||
err = vmodl.RuntimeFault()
|
||||
err.msg = 'runtime_fault'
|
||||
self.mock_host_vsan_system.RemoveDisk_Task = \
|
||||
MagicMock(side_effect=err)
|
||||
with self.assertRaises(VMwareRuntimeError) as excinfo:
|
||||
vsan.remove_capacity_from_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.assertEqual(excinfo.exception.strerror, 'runtime_fault')
|
||||
|
||||
def test_wait_for_tasks(self):
|
||||
mock_wait_for_task = MagicMock()
|
||||
with patch('salt.utils.vmware.wait_for_task',
|
||||
mock_wait_for_task):
|
||||
vsan.remove_capacity_from_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
mock_wait_for_task.assert_called_once_with(
|
||||
self.mock_task, 'fake_hostname', 'remove_capacity')
|
||||
|
||||
def test_result(self):
|
||||
res = vsan.remove_capacity_from_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.assertTrue(res)
|
||||
|
||||
|
||||
@skipIf(NO_MOCK, NO_MOCK_REASON)
|
||||
@skipIf(not HAS_PYVMOMI, 'The \'pyvmomi\' library is missing')
|
||||
@skipIf(not HAS_PYVSAN, 'The \'vsan\' ext library is missing')
|
||||
class RemoveDiskgroup(TestCase):
|
||||
'''Tests for salt.utils.vsan.remove_diskgroup'''
|
||||
def setUp(self):
|
||||
self.mock_si = MagicMock()
|
||||
self.mock_task = MagicMock()
|
||||
self.mock_remove_disk_mapping = \
|
||||
MagicMock(return_value=self.mock_task)
|
||||
self.mock_host_vsan_system = MagicMock(
|
||||
RemoveDiskMapping_Task=self.mock_remove_disk_mapping)
|
||||
self.mock_host_ref = MagicMock()
|
||||
self.mock_cache_disk = MagicMock()
|
||||
self.mock_diskgroup = MagicMock(ssd=self.mock_cache_disk)
|
||||
self.mock_cap_disk1 = MagicMock()
|
||||
self.mock_cap_disk2 = MagicMock()
|
||||
self.mock_spec = MagicMock()
|
||||
patches = (
|
||||
('salt.utils.vmware.get_managed_object_name',
|
||||
MagicMock(return_value='fake_hostname')),
|
||||
('salt.utils.vsan.get_host_vsan_system',
|
||||
MagicMock(return_value=self.mock_host_vsan_system)),
|
||||
('salt.utils.vsan.vim.HostMaintenanceSpec',
|
||||
MagicMock(return_value=self.mock_spec)),
|
||||
('salt.utils.vsan.vim.VsanHostDecommissionMode', MagicMock()),
|
||||
('salt.utils.vmware.wait_for_task', MagicMock()))
|
||||
for mod, mock in patches:
|
||||
patcher = patch(mod, mock)
|
||||
patcher.start()
|
||||
self.addCleanup(patcher.stop)
|
||||
|
||||
def test_get_hostname(self):
|
||||
mock_get_managed_object_name = MagicMock(return_value='fake_hostname')
|
||||
with patch('salt.utils.vmware.get_managed_object_name',
|
||||
mock_get_managed_object_name):
|
||||
vsan.remove_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup)
|
||||
mock_get_managed_object_name.assert_called_once_with(
|
||||
self.mock_host_ref)
|
||||
|
||||
def test_maintenance_mode_evacuate_all_data(self):
|
||||
vsan.remove_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup)
|
||||
vsan.remove_capacity_from_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.assertEqual(self.mock_spec.vsanMode.objectAction,
|
||||
vim.VsanHostDecommissionModeObjectAction.evacuateAllData)
|
||||
|
||||
def test_maintenance_mode_no_action(self):
|
||||
vsan.remove_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup)
|
||||
vsan.remove_capacity_from_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2],
|
||||
data_evacuation=False)
|
||||
self.assertEqual(self.mock_spec.vsanMode.objectAction,
|
||||
vim.VsanHostDecommissionModeObjectAction.noAction)
|
||||
|
||||
def test_remove_disk_mapping(self):
|
||||
vsan.remove_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup)
|
||||
vsan.remove_capacity_from_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup,
|
||||
[self.mock_cap_disk1, self.mock_cap_disk2])
|
||||
self.mock_remove_disk_mapping.assert_called_once_with(
|
||||
mapping=[self.mock_diskgroup],
|
||||
maintenanceSpec=self.mock_spec)
|
||||
|
||||
def test_remove_disk_mapping_raise_no_permission(self):
|
||||
vsan.remove_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup)
|
||||
err = vim.fault.NoPermission()
|
||||
err.privilegeId = 'Fake privilege'
|
||||
self.mock_host_vsan_system.RemoveDiskMapping_Task = \
|
||||
MagicMock(side_effect=err)
|
||||
with self.assertRaises(VMwareApiError) as excinfo:
|
||||
vsan.remove_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup)
|
||||
self.assertEqual(excinfo.exception.strerror,
|
||||
'Not enough permissions. Required privilege: '
|
||||
'Fake privilege')
|
||||
|
||||
def test_remove_disk_mapping_raise_vim_fault(self):
|
||||
err = vim.fault.VimFault()
|
||||
err.msg = 'vim_fault'
|
||||
self.mock_host_vsan_system.RemoveDiskMapping_Task = \
|
||||
MagicMock(side_effect=err)
|
||||
with self.assertRaises(VMwareApiError) as excinfo:
|
||||
vsan.remove_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup)
|
||||
self.assertEqual(excinfo.exception.strerror, 'vim_fault')
|
||||
|
||||
def test_remove_disk_mapping_raise_runtime_fault(self):
|
||||
err = vmodl.RuntimeFault()
|
||||
err.msg = 'runtime_fault'
|
||||
self.mock_host_vsan_system.RemoveDiskMapping_Task = \
|
||||
MagicMock(side_effect=err)
|
||||
with self.assertRaises(VMwareRuntimeError) as excinfo:
|
||||
vsan.remove_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup)
|
||||
self.assertEqual(excinfo.exception.strerror, 'runtime_fault')
|
||||
|
||||
def test_wait_for_tasks(self):
|
||||
mock_wait_for_task = MagicMock()
|
||||
with patch('salt.utils.vmware.wait_for_task',
|
||||
mock_wait_for_task):
|
||||
vsan.remove_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup)
|
||||
mock_wait_for_task.assert_called_once_with(
|
||||
self.mock_task, 'fake_hostname', 'remove_diskgroup')
|
||||
|
||||
def test_result(self):
|
||||
res = vsan.remove_diskgroup(
|
||||
self.mock_si, self.mock_host_ref, self.mock_diskgroup)
|
||||
self.assertTrue(res)
|
||||
|
||||
|
||||
@skipIf(NO_MOCK, NO_MOCK_REASON)
|
||||
@skipIf(not HAS_PYVMOMI, 'The \'pyvmomi\' library is missing')
|
||||
@skipIf(not HAS_PYVSAN, 'The \'vsan\' ext library is missing')
|
||||
|
||||
Loading…
Reference in New Issue
Block a user