def _get_port_info_by_name(self, name, port_list=None):
if port_list is None:
port_list = self.get_ports(None)
ports = [port for port in port_list if port.config.name == name]
if not ports:
raise exceptions.PortNotFound(id=name)
if len(ports) > 1:
LOG.warn(_LW("Multiple ports found for name %s."), name)
return ports[0]
def _get_port_info_by_portkey(self, port_key):
"""pg - ManagedObjectReference of Port Group"""
criteria = self.builder.port_criteria(port_key=port_key)
port_info = self.connection.invoke_api(self.connection.vim,
'FetchDVPorts',
self._dvs,
criteria=criteria)
if not port_info:
raise exceptions.PortNotFound(id=port_key)
return port_info[0]
def test_switch_port_blocked_state_failed(self):
port = {'id': 'fake_port_id'}
with mock.patch.object(self.controller,
'get_port_info') as get_port_info_mock:
get_port_info_mock.side_effect = exceptions.PortNotFound(id='')
self.controller.switch_port_blocked_state(port)
self.connection.invoke_api.assert_not_called()
get_port_info_mock.side_effect = vmware_exceptions.VimException()
self.assertRaises(exceptions.VMWareDVSException,
self.controller.switch_port_blocked_state, port)
class DVSControllerTestCase(DVSControllerBaseTestCase):
"""Tests of DVSController that don't call API methods"""
def test_creation(self):
self.assertEqual(self.cluster, self.controller._inventory)
self.assertEqual(self.dvs, self.controller._dvs)
self.assertIs(self.connection, self.controller.connection)
def test__get_net_name(self):
expect = self.dvs_name + fake_network['id']
self.assertEqual(expect, self.controller._get_net_name(fake_network))
@mock.patch('networking_vsphere.utils.dvs_util.DVSController.'
'get_port_info')
def test_release_port(self, get_port_info_mock):
dvs_port = mock.Mock(key=fake_port['dvs_port_key'])
get_port_info_mock.return_value = dvs_port
self.controller._blocked_ports.add(dvs_port.key)
self.connection.wait_for_task.return_value = mock.Mock(state="error")
self.controller.release_port(fake_port)
self.assertNotIn(dvs_port.key, self.controller._blocked_ports)
get_port_info_mock.assert_called_once_with(fake_port)
self.assertEqual(1, self.connection.invoke_api.call_count)
self.assertEqual(
mock.call(self.vim, 'ReconfigureDVPort_Task', self.dvs,
port=mock.ANY),
self.connection.invoke_api.call_args)
args, kwargs = self.connection.invoke_api.call_args
update_spec = kwargs['port'][0]
self.assertEqual(dvs_port.key, update_spec.key)
self.assertEqual('remove', update_spec.operation)
self.connection.wait_for_task.return_value = mock.Mock(state="success")
self.controller.release_port(fake_port)
@mock.patch('networking_vsphere.utils.dvs_util.DVSController.'
'get_port_info', side_effect=exceptions.PortNotFound())
def test_release_port_not_found(self, get_port_info_mock):
self.controller.release_port(fake_port)
get_port_info_mock.assert_called_once_with(fake_port)
self.connection.invoke_api.assert_not_called()
def test_get_port_info(self):
port_with_dvs_key = {'binding:vif_details': {'dvs_port_key': 0},
'id': 'port_with_dvs_key'}
port = {'id': 'fake_port_id'}
with mock.patch.object(self.controller, '_get_port_info_by_portkey') \
as get_port_info_by_key_mock, \
mock.patch.object(self.controller, '_get_port_info_by_name') \
as get_port_info_by_name_mock:
self.controller.get_port_info(port_with_dvs_key)
get_port_info_by_key_mock.assert_called_once_with(0)
get_port_info_by_name_mock.assert_not_called()
get_port_info_by_key_mock.reset_mock()
get_port_info_by_name_mock.reset_mock()
self.controller.get_port_info(port)
get_port_info_by_key_mock.assert_not_called()
get_port_info_by_name_mock.assert_called_once_with(port['id'])
def test_get_port_info_for_port_with_dvs_key(self):
port = {'binding:vif_details': {'dvs_port_key': 0},
'id': 'fake_port_id'}
self.connection.invoke_api = mock.Mock(return_value=[])
self.assertRaises(exceptions.PortNotFound,
self.controller.get_port_info,
port)
port_info = mock.Mock()
self.connection.invoke_api = mock.Mock(return_value=[port_info])
result = self.controller.get_port_info(port)
self.assertEqual(result, port_info)
def test_get_port_info_without_port_list(self):
port = {'id': 'fake_port_id'}
dummy_port_config = mock.Mock()
dummy_port_config.name = 'dummy_port_id'
dummy_port = mock.Mock(key='dummmy_port_key', config=dummy_port_config)
with mock.patch.object(self.controller, 'get_ports') as get_ports_mock:
get_ports_mock.return_value = [dummy_port]
self.assertRaises(exceptions.PortNotFound,
self.controller.get_port_info,
port)
port_config = mock.Mock()
port_config.name = 'fake_port_id'
fake_port_info = mock.Mock(key='fake_port_key', config=port_config)
get_ports_mock.return_value = [fake_port_info, dummy_port]
result = self.controller.get_port_info(port)
self.assertEqual(result, fake_port_info)
def _get_connection_mock(self, dvs_name):
return mock.Mock(vim=self.vim)
class VirtualE1000(object):
def __init__(self, port_key, switch_uuid):
self.backing = mock.Mock()
self.backing.port.portKey = port_key
self.backing.port.switchUuid = switch_uuid