def setUp(self):
super(BaseTestListenerManager, self).setUp()
self.in_listener = data_models.Listener(id='listener1')
self.listener2 = data_models.Listener(id='listener2')
self.in_listener.loadbalancer = self.in_lb
self.listener2.loadbalancer = self.in_lb
self.refresh = self.driver.loadbalancer.refresh
def setUp(self):
super(TestListenerManager, self).setUp()
self.in_listener = data_models.Listener(id='listener1')
self.listener2 = data_models.Listener(id='listener2')
self.in_lb.listeners = [self.in_listener, self.listener2]
self.in_listener.loadbalancer = self.in_lb
self.listener2.loadbalancer = self.in_lb
def setUp(self):
super(BaseTestEdgeLbaasV2, self).setUp()
self.context = context.get_admin_context()
self.edge_driver = lb_driver_v2.EdgeLoadbalancerDriverV2()
self.lbv2_driver = mock.Mock()
self.core_plugin = mock.Mock()
base_mgr.LoadbalancerBaseManager._lbv2_driver = self.lbv2_driver
base_mgr.LoadbalancerBaseManager._core_plugin = self.core_plugin
self._patch_lb_plugin(self.lbv2_driver, self._tested_entity)
self._patch_nsxlib_lb_clients(self.core_plugin)
self.lb = lb_models.LoadBalancer(LB_ID, LB_TENANT_ID, 'lb1', '',
'some-subnet', 'port-id', LB_VIP)
self.listener = lb_models.Listener(LISTENER_ID, LB_TENANT_ID,
'listener1', 'Dummy', None, LB_ID,
'HTTP', protocol_port=80,
loadbalancer=self.lb)
self.https_listener = lb_models.Listener(
LISTENER_ID, LB_TENANT_ID, 'listener1', '', None, LB_ID,
'HTTPS', protocol_port=443, loadbalancer=self.lb)
self.terminated_https_listener = lb_models.Listener(
LISTENER_ID, LB_TENANT_ID, 'listener1', '', None, LB_ID,
'TERMINATED_HTTPS', protocol_port=443, loadbalancer=self.lb)
self.pool = lb_models.Pool(POOL_ID, LB_TENANT_ID, 'pool1', '',
None, 'HTTP', 'ROUND_ROBIN',
loadbalancer_id=LB_ID,
listener=self.listener,
listeners=[self.listener],
loadbalancer=self.lb)
self.member = lb_models.Member(MEMBER_ID, LB_TENANT_ID, POOL_ID,
MEMBER_ADDRESS, 80, 1, pool=self.pool,
name='member1')
self.hm = lb_models.HealthMonitor(HM_ID, LB_TENANT_ID, 'PING', 3, 3,
1, pool=self.pool, name='hm1')
self.l7policy = lb_models.L7Policy(L7POLICY_ID, LB_TENANT_ID,
name='policy-test',
description='policy-desc',
listener_id=LISTENER_ID,
action='REDIRECT_TO_POOL',
redirect_pool_id=POOL_ID,
listener=self.listener,
position=1)
self.l7rule = lb_models.L7Rule(L7RULE_ID, LB_TENANT_ID,
l7policy_id=L7POLICY_ID,
compare_type='EQUAL_TO',
invert=False,
type='HEADER',
key='key1',
value='val1',
policy=self.l7policy)
def test_update_listener_failed(self, mlistener):
loadbalancer = data_models.LoadBalancer(id='1')
old_listener = data_models.Listener(id=1, loadbalancer_id='1',
loadbalancer=loadbalancer,
protocol_port=80)
listener = data_models.Listener(id=1, loadbalancer_id='1',
loadbalancer=loadbalancer,
protocol_port=81)
mlistener.side_effect = [listener, old_listener]
self.driver_mock.listener.update.side_effect = Exception
self.mgr.update_listener(mock.Mock(), old_listener, listener)
self.driver_mock.listener.update.assert_called_once_with(old_listener,
listener)
self.update_statuses.assert_called_once_with(listener, error=True)
def _create_fake_models(self):
# This id is used for all the entities.
id = 'test_id'
lb = data_models.LoadBalancer(id=id)
sni_container = data_models.SNI(listener_id=id)
listener = data_models.Listener(id=id,
loadbalancer=lb,
sni_containers=[sni_container])
pool = data_models.Pool(id=id, loadbalancer=lb)
member = data_models.Member(id=id, pool=pool)
hm = data_models.HealthMonitor(id=id, pool=pool)
l7policy = data_models.L7Policy(
id=id,
listener=listener,
redirect_pool_id=pool.id,
action=constants.L7_POLICY_ACTION_REDIRECT_TO_POOL)
l7rule = data_models.L7Rule(
id=id,
policy=l7policy,
type=constants.L7_RULE_TYPE_PATH,
compare_type=constants.L7_RULE_COMPARE_TYPE_STARTS_WITH,
value='/api')
lb.listeners = [listener]
lb.pools = [pool]
listener.default_pool = pool
listener.l7policies = [l7policy]
l7policy.rules = [l7rule]
pool.members = [member]
pool.healthmonitor = hm
return lb
def test_update_statuses_pool(self):
self.update_statuses_patcher.stop()
pool = data_models.Pool(id='1')
listener = data_models.Listener(id='1', default_pool=pool)
lb = data_models.LoadBalancer(id='1', listeners=[listener])
listener.loadbalancer = lb
pool.loadbalancer = lb
self.mgr._update_statuses(pool)
self.assertEqual(2, self.rpc_mock.update_status.call_count)
calls = [
mock.call('pool',
pool.id,
provisioning_status=constants.ACTIVE,
operating_status=lb_const.ONLINE),
mock.call('loadbalancer',
lb.id,
provisioning_status=constants.ACTIVE,
operating_status=None)
]
self.rpc_mock.update_status.assert_has_calls(calls)
self.rpc_mock.update_status.reset_mock()
self.mgr._update_statuses(pool, error=True)
self.assertEqual(2, self.rpc_mock.update_status.call_count)
calls = [
mock.call('pool',
pool.id,
provisioning_status=constants.ERROR,
operating_status=lb_const.OFFLINE),
mock.call('loadbalancer',
lb.id,
provisioning_status=constants.ACTIVE,
operating_status=None)
]
self.rpc_mock.update_status.assert_has_calls(calls)
def test_update(self):
new_listener = lb_models.Listener(LISTENER_ID, LB_TENANT_ID,
'l-name', '', None, LB_ID,
'HTTP', protocol_port=8000,
loadbalancer=self.lb)
with mock.patch.object(nsxv_db, 'get_nsxv_lbaas_listener_binding'
) as mock_get_listener_binding, \
mock.patch.object(nsxv_db, 'get_nsxv_lbaas_loadbalancer_binding'
) as mock_get_lb_binding, \
mock.patch.object(self.edge_driver.vcns, 'update_app_profile'
) as mock_upd_app_prof, \
mock.patch.object(self.edge_driver.vcns, 'update_vip'
) as mock_upd_vip:
mock_get_listener_binding.return_value = LISTENER_BINDING
mock_get_lb_binding.return_value = LB_BINDING
self.edge_driver.listener.update(
self.context, self.listener, new_listener)
mock_upd_app_prof.assert_called_with(LB_EDGE_ID,
EDGE_APP_PROFILE_ID,
EDGE_APP_PROF_DEF)
edge_vip_def = EDGE_VIP_DEF.copy()
edge_vip_def['port'] = 8000
mock_upd_vip.assert_called_with(LB_EDGE_ID, EDGE_VIP_ID,
edge_vip_def)
mock_successful_completion = (
self.lbv2_driver.listener.successful_completion)
mock_successful_completion.assert_called_with(self.context,
new_listener)
def test_deployable(self):
# test None
ret_val = self.driver.deployable(None)
self.assertFalse(ret_val)
# test no listeners
ret_val = self.driver.deployable(self.lb)
self.assertFalse(ret_val)
# test no acceptable listeners
listener = data_models.Listener(
provisioning_status=constants.PENDING_DELETE, admin_state_up=True)
self.lb.listeners.append(listener)
ret_val = self.driver.deployable(self.lb)
self.assertFalse(ret_val)
listener.provisioning_status = constants.PENDING_CREATE
listener.admin_state_up = False
ret_val = self.driver.deployable(self.lb)
self.assertFalse(ret_val)
# test bad lb status
listener.admin_state_up = True
self.lb.provisioning_status = constants.PENDING_DELETE
self.lb.admin_state_up = True
ret_val = self.driver.deployable(self.lb)
self.assertFalse(ret_val)
self.lb.provisioning_status = constants.PENDING_UPDATE
self.lb.admin_state_up = False
ret_val = self.driver.deployable(self.lb)
self.assertFalse(ret_val)
# test everything good
self.lb.admin_state_up = True
ret_val = self.driver.deployable(self.lb)
self.assertTrue(ret_val)
def test_update_statuses_healthmonitor(self):
self.update_statuses_patcher.stop()
hm = data_models.HealthMonitor(id='1')
pool = data_models.Pool(id='1', healthmonitor=hm)
hm.pool = pool
listener = data_models.Listener(id='1', default_pool=pool)
lb = data_models.LoadBalancer(id='1', listeners=[listener])
listener.loadbalancer = lb
pool.loadbalancer = lb
self.mgr._update_statuses(hm)
self.assertEqual(2, self.rpc_mock.update_status.call_count)
calls = [mock.call('healthmonitor', hm.id,
provisioning_status=constants.ACTIVE,
operating_status=None),
mock.call('loadbalancer', lb.id,
provisioning_status=constants.ACTIVE,
operating_status=None)]
self.rpc_mock.update_status.assert_has_calls(calls)
self.rpc_mock.update_status.reset_mock()
self.mgr._update_statuses(hm, error=True)
self.assertEqual(2, self.rpc_mock.update_status.call_count)
calls = [mock.call('healthmonitor', hm.id,
provisioning_status=constants.ERROR,
operating_status=None),
mock.call('loadbalancer', lb.id,
provisioning_status=constants.ACTIVE,
operating_status=None)]
self.rpc_mock.update_status.assert_has_calls(calls)
def setUp(self):
super(BaseTestEdgeLbaasV2, self).setUp()
self.context = context.get_admin_context()
callbacks = mock.Mock()
callbacks.plugin = mock.Mock()
self.edge_driver = vcns_driver.VcnsDriver(callbacks)
self.lbv2_driver = mock.Mock()
self.core_plugin = mock.Mock()
base_mgr.EdgeLoadbalancerBaseManager._lbv2_driver = self.lbv2_driver
base_mgr.EdgeLoadbalancerBaseManager._core_plugin = self.core_plugin
self._patch_lb_plugin(self.lbv2_driver, self._tested_entity)
self.lb = lb_models.LoadBalancer(LB_ID, LB_TENANT_ID, 'lb-name', '',
'some-subnet', 'port-id', LB_VIP)
self.listener = lb_models.Listener(LISTENER_ID, LB_TENANT_ID,
'l-name', '', None, LB_ID,
'HTTP', protocol_port=80,
loadbalancer=self.lb)
self.pool = lb_models.Pool(POOL_ID, LB_TENANT_ID, 'pool-name', '',
None, 'HTTP', 'ROUND_ROBIN',
listener=self.listener)
self.member = lb_models.Member(MEMBER_ID, LB_TENANT_ID, POOL_ID,
MEMBER_ADDRESS, 80, 1, pool=self.pool)
self.hm = lb_models.HealthMonitor(HM_ID, LB_TENANT_ID, 'PING', 3, 3,
1, pool=self.pool)
def test_is_active(self):
# test no listeners
ret_val = self.driver._is_active(self.lb)
self.assertFalse(ret_val)
# test bad VIP status
listener = data_models.Listener(
provisioning_status=constants.PENDING_CREATE, admin_state_up=True)
self.lb.listeners.append(listener)
self.lb.vip_port.status = constants.DOWN
ret_val = self.driver._is_active(self.lb)
self.assertFalse(ret_val)
self.lb.vip_port.status = constants.PENDING_CREATE
self.lb.vip_port.admin_state_up = False
ret_val = self.driver._is_active(self.lb)
self.assertFalse(ret_val)
# test bad LB status
self.lb.vip_port.admin_state_up = True
self.lb.operating_status = 'OFFLINE'
ret_val = self.driver._is_active(self.lb)
self.assertFalse(ret_val)
# test everything good
self.lb.operating_status = 'ONLINE'
ret_val = self.driver._is_active(self.lb)
self.assertTrue(ret_val)
def test_delete_listener(self, mlistener):
loadbalancer = data_models.LoadBalancer(id='1')
listener = data_models.Listener(id=1, loadbalancer_id='1',
loadbalancer=loadbalancer,
protocol_port=80)
mlistener.return_value = listener
self.mgr.delete_listener(mock.Mock(), listener.to_dict())
self.driver_mock.listener.delete.assert_called_once_with(listener)
def test_create(self):
self.lb_manager.refresh = mock.Mock()
self.lb_manager.create(self.in_lb)
self.assertFalse(self.lb_manager.refresh.called)
self.lb_manager.refresh.reset_mock()
self.in_lb.listeners.append(data_models.Listener(id='listener1'))
self.lb_manager.create(self.in_lb)
self.lb_manager.refresh.assert_called_once_with(self.in_lb)
def test_delete_pool(self, mpool):
loadbalancer = data_models.LoadBalancer(id='1')
listener = data_models.Listener(id=1,
loadbalancer_id='1',
loadbalancer=loadbalancer)
pool = data_models.Pool(id='1', listener=listener, protocol='HTTPS')
mpool.return_value = pool
self.mgr.delete_pool(mock.Mock(), pool.to_dict())
self.driver_mock.pool.delete.assert_called_once_with(pool)
def test_delete_monitor(self, mmonitor):
loadbalancer = data_models.LoadBalancer(id='1')
listener = data_models.Listener(id=1,
loadbalancer_id='1',
loadbalancer=loadbalancer)
pool = data_models.Pool(id='1', listener=listener, protocol='HTTPS')
monitor = data_models.HealthMonitor(id='1', pool=pool)
mmonitor.return_value = monitor
self.mgr.delete_healthmonitor(mock.Mock(), monitor.to_dict())
self.driver_mock.healthmonitor.delete.assert_called_once_with(monitor)
def test_delete_member(self, mmember):
loadbalancer = data_models.LoadBalancer(id='1')
listener = data_models.Listener(id=1,
loadbalancer_id='1',
loadbalancer=loadbalancer)
pool = data_models.Pool(id='1', listener=listener, protocol='HTTPS')
member = data_models.Member(id='1', pool=pool, weight=1)
mmember.return_value = member
self.mgr.delete_member(mock.Mock(), member.to_dict())
self.driver_mock.member.delete.assert_called_once_with(member)
def test_create_listener(self, mlistener):
loadbalancer = data_models.LoadBalancer(id='1')
listener = data_models.Listener(id=1, loadbalancer_id='1',
loadbalancer=loadbalancer)
self.assertIn(loadbalancer.id, self.mgr.instance_mapping)
mlistener.return_value = listener
self.mgr.create_listener(mock.Mock(), listener.to_dict())
self.driver_mock.listener.create.assert_called_once_with(listener)
self.update_statuses.assert_called_once_with(listener)
def setUp(self):
super(BaseTestEdgeLbaasV2, self).setUp()
self.context = context.get_admin_context()
callbacks = mock.Mock()
callbacks.plugin = mock.Mock()
self.edge_driver = vcns_driver.VcnsDriver(callbacks)
self.lbv2_driver = mock.Mock()
self.core_plugin = mock.Mock()
base_mgr.LoadbalancerBaseManager._lbv2_driver = self.lbv2_driver
base_mgr.LoadbalancerBaseManager._core_plugin = self.core_plugin
self._patch_lb_plugin(self.lbv2_driver, self._tested_entity)
self.lb = lb_models.LoadBalancer(LB_ID, LB_TENANT_ID, 'lb-name', '',
'some-subnet', 'port-id', LB_VIP)
self.listener = lb_models.Listener(LISTENER_ID, LB_TENANT_ID,
'l-name', '', None, LB_ID,
'HTTP', protocol_port=80,
loadbalancer=self.lb)
self.sess_persist = lb_models.SessionPersistence(type='HTTP_COOKIE')
self.pool = lb_models.Pool(POOL_ID, LB_TENANT_ID, 'pool-name', '',
None, 'HTTP', 'ROUND_ROBIN',
loadbalancer_id=LB_ID,
listener=self.listener,
listeners=[self.listener],
loadbalancer=self.lb,
session_persistence=self.sess_persist)
self.listener.default_pool = self.pool
self.member = lb_models.Member(MEMBER_ID, LB_TENANT_ID, POOL_ID,
MEMBER_ADDRESS, 80, 1, pool=self.pool)
self.hm = lb_models.HealthMonitor(HM_ID, LB_TENANT_ID, 'PING', 3, 3,
1, pool=self.pool)
self.l7policy = lb_models.L7Policy(L7POL_ID, LB_TENANT_ID,
name='policy-test',
description='policy-desc',
listener_id=LISTENER_ID,
action='REJECT',
listener=self.listener,
position=1)
self.l7rule1 = lb_models.L7Rule(L7RULE_ID1, LB_TENANT_ID,
l7policy_id=L7POL_ID,
compare_type='EQUAL_TO',
invert=False,
type='HEADER',
key='key1',
value='val1',
policy=self.l7policy)
self.l7rule2 = lb_models.L7Rule(L7RULE_ID2, LB_TENANT_ID,
l7policy_id=L7POL_ID,
compare_type='STARTS_WITH',
invert=True,
type='PATH',
value='/images',
policy=self.l7policy)
def test_create_pool(self, mpool):
loadbalancer = data_models.LoadBalancer(id='1')
listener = data_models.Listener(id=1,
loadbalancer_id='1',
loadbalancer=loadbalancer)
pool = data_models.Pool(id='1', listener=listener)
mpool.return_value = pool
self.mgr.create_pool(mock.Mock(), pool.to_dict())
self.driver_mock.pool.create.assert_called_once_with(pool)
self.update_statuses.assert_called_once_with(pool)
def test_update_pool(self, mpool):
loadbalancer = data_models.LoadBalancer(id='1')
listener = data_models.Listener(id=1,
loadbalancer_id='1',
loadbalancer=loadbalancer)
pool = data_models.Pool(id='1', listener=listener, protocol='HTTPS')
old_pool = data_models.Pool(id='1', listener=listener, protocol='HTTP')
mpool.side_effect = [pool, old_pool]
self.mgr.update_pool(mock.Mock(), old_pool.to_dict(), pool.to_dict())
self.driver_mock.pool.update.assert_called_once_with(old_pool, pool)
self.update_statuses.assert_called_once_with(pool)
def test_create_pool_failed(self, mpool):
loadbalancer = data_models.LoadBalancer(id='1')
listener = data_models.Listener(id=1,
loadbalancer_id='1',
loadbalancer=loadbalancer)
pool = data_models.Pool(id='1', listener=listener)
mpool.return_value = pool
self.driver_mock.pool.create.side_effect = Exception
self.mgr.create_pool(mock.Mock(), pool)
self.driver_mock.pool.create.assert_called_once_with(pool)
self.update_statuses.assert_called_once_with(pool, error=True)
def _create_fake_models(self):
id = 'name-001'
lb = data_models.LoadBalancer(id=id)
listener = data_models.Listener(id=id, loadbalancer=lb)
pool = data_models.Pool(id=id, listener=listener)
member = data_models.Member(id=id, pool=pool)
hm = data_models.HealthMonitor(id=id, pool=pool)
lb.listeners = [listener]
listener.default_pool = pool
pool.members = [member]
pool.healthmonitor = hm
return lb
def test_create_monitor_failed(self, mmonitor):
loadbalancer = data_models.LoadBalancer(id='1')
listener = data_models.Listener(id=1,
loadbalancer_id='1',
loadbalancer=loadbalancer)
pool = data_models.Pool(id='1', listener=listener, protocol='HTTPS')
monitor = data_models.HealthMonitor(id='1', pool=pool)
mmonitor.return_value = monitor
self.driver_mock.healthmonitor.create.side_effect = Exception
self.mgr.create_healthmonitor(mock.Mock(), monitor.to_dict())
self.driver_mock.healthmonitor.create.assert_called_once_with(monitor)
self.update_statuses.assert_called_once_with(monitor, error=True)
def test_update(self):
new_listener = lb_models.Listener(LISTENER_ID, LB_TENANT_ID,
'listener1-new', 'new-description',
None, LB_ID, protocol_port=8000,
loadbalancer=self.lb)
self.edge_driver.listener.update(self.context, self.listener,
new_listener)
mock_successful_completion = (
self.lbv2_driver.listener.successful_completion)
mock_successful_completion.assert_called_with(self.context,
new_listener)
def test_update_monitor(self, mmonitor):
loadbalancer = data_models.LoadBalancer(id='1')
listener = data_models.Listener(id=1,
loadbalancer_id='1',
loadbalancer=loadbalancer)
pool = data_models.Pool(id='1', listener=listener, protocol='HTTPS')
monitor = data_models.HealthMonitor(id='1', pool=pool, delay=1)
old_monitor = data_models.HealthMonitor(id='1', pool=pool, delay=2)
mmonitor.side_effect = [monitor, old_monitor]
self.mgr.update_healthmonitor(mock.Mock(), old_monitor.to_dict(),
monitor.to_dict())
self.driver_mock.healthmonitor.update.assert_called_once_with(
old_monitor, monitor)
self.update_statuses.assert_called_once_with(monitor)
def test_update_member(self, mmember):
loadbalancer = data_models.LoadBalancer(id='1')
listener = data_models.Listener(id=1,
loadbalancer_id='1',
loadbalancer=loadbalancer)
pool = data_models.Pool(id='1', listener=listener, protocol='HTTPS')
member = data_models.Member(id='1', pool=pool, weight=1)
old_member = data_models.Member(id='1', pool=pool, weight=2)
mmember.side_effect = [member, old_member]
self.mgr.update_member(mock.Mock(), old_member.to_dict(),
member.to_dict())
self.driver_mock.member.update.assert_called_once_with(
old_member, member)
self.update_statuses.assert_called_once_with(member)
def _create_fake_models(self):
# This id is used for all the entities.
id = 'test_id'
lb = data_models.LoadBalancer(id=id)
sni_container = data_models.SNI(listener_id=id)
listener = data_models.Listener(id=id,
loadbalancer=lb,
sni_containers=[sni_container])
pool = data_models.Pool(id=id, listener=listener)
member = data_models.Member(id=id, pool=pool)
hm = data_models.HealthMonitor(id=id, pool=pool)
lb.listeners = [listener]
listener.default_pool = pool
pool.members = [member]
pool.healthmonitor = hm
return lb
def _create_fake_models(self, children=True, graph=False):
# This id is used for all the entities.
id = 'test_id'
lb = data_models.LoadBalancer(id=id)
if not children:
return lb
sni_container = data_models.SNI(listener_id=id)
listener = data_models.Listener(id=id,
loadbalancer=lb,
sni_containers=[sni_container])
pool = data_models.Pool(id=id, loadbalancer=lb)
member = data_models.Member(id=id, pool=pool)
hm = data_models.HealthMonitor(id=id, pool=pool)
sp = data_models.SessionPersistence(pool_id=pool.id, pool=pool)
l7policy = data_models.L7Policy(
id=id,
listener=listener,
listener_id=listener.id,
action=constants.L7_POLICY_ACTION_REDIRECT_TO_POOL)
l7rule = data_models.L7Rule(
id=id,
policy=l7policy,
type=constants.L7_RULE_TYPE_PATH,
compare_type=constants.L7_RULE_COMPARE_TYPE_STARTS_WITH,
value='/api')
lb.listeners = [listener]
lb.pools = [pool]
if graph:
r_pool = data_models.Pool(id=id, loadbalancer=lb)
r_member = data_models.Member(id=id, pool=r_pool)
r_pool.members = [r_member]
l7policy.redirect_pool = r_pool
l7policy.redirect_pool_id = r_pool.id
lb.pools.append(r_pool)
else:
l7policy.redirect_pool = pool
l7policy.redirect_pool_id = pool.id
listener.default_pool = pool
listener.l7_policies = [l7policy]
l7policy.rules = [l7rule]
pool.members = [member]
pool.session_persistence = sp
pool.healthmonitor = hm
return lb
def _get_faked_model(obj):
lb = data_models.LoadBalancer(id='test_lb')
if obj == 'lbaas/loadbalancer':
return lb
pool = data_models.Pool(id='test_pool_id', loadbalancer=lb)
if obj == 'lbaas/pool':
return pool
listener = data_models.Listener(id='test_listener_id', loadbalancer=lb)
if obj == 'lbaas/listener':
return listener
member = data_models.Member(id='test_member_id', pool=pool)
if obj == 'lbaas/member':
return member
hm = data_models.HealthMonitor(id='test_health_monitor_id', pool=pool)
return hm
def test_update(self):
new_listener = lb_models.Listener(LISTENER_ID, LB_TENANT_ID,
'listener1-new', 'new-description',
None, LB_ID, protocol_port=80,
loadbalancer=self.lb)
with mock.patch.object(self.core_plugin, 'get_floatingips'
) as mock_get_floatingips, \
mock.patch.object(nsx_db, 'get_nsx_lbaas_listener_binding'
) as mock_get_listener_binding:
mock_get_floatingips.return_value = []
mock_get_listener_binding.return_value = LISTENER_BINDING
self.edge_driver.listener.update(self.context, self.listener,
new_listener)
mock_successful_completion = (
self.lbv2_driver.listener.successful_completion)
mock_successful_completion.assert_called_with(self.context,
new_listener,
delete=False)
