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