def test_member_delete_missing_subnet_id(self):
self.driver._ovn_helper._get_subnet_from_pool.return_value = (
self.ref_member.subnet_id)
info = {
'id': self.ref_member.member_id,
'address': self.ref_member.address,
'protocol_port': self.ref_member.protocol_port,
'pool_id': self.ref_member.pool_id,
'subnet_id': self.ref_member.subnet_id
}
expected_dict = {
'type': ovn_const.REQ_TYPE_MEMBER_DELETE,
'info': info
}
info_dvr = {
'id': self.ref_member.member_id,
'address': self.ref_member.address,
'pool_id': self.ref_member.pool_id,
'subnet_id': self.ref_member.subnet_id,
'action': ovn_const.REQ_INFO_MEMBER_DELETED
}
expected_dict_dvr = {
'type': ovn_const.REQ_TYPE_HANDLE_MEMBER_DVR,
'info': info_dvr
}
member = copy.copy(self.ref_member)
member.subnet_id = data_models.UnsetType()
self.driver.member_delete(member)
expected = [mock.call(expected_dict), mock.call(expected_dict_dvr)]
self.mock_add_request.assert_has_calls(expected)
def test_member_create_no_subnet_provided(self):
self.ref_member.subnet_id = data_models.UnsetType()
self.assertRaises(exceptions.UnsupportedOptionError,
self.driver.member_create, self.ref_member)
self.ref_member.subnet_id = None
self.assertRaises(exceptions.UnsupportedOptionError,
self.driver.member_create, self.ref_member)
def test_member_create_no_subnet_provided_get_from_pool(self):
self.driver._ovn_helper._get_subnet_from_pool.return_value = (
self.ref_member.subnet_id)
member = copy.copy(self.ref_member)
member.subnet_id = data_models.UnsetType()
self._test_member_create(member)
member.subnet_id = None
self._test_member_create(member)
def test_pool_update_unset_new_admin_state_up(self):
self.ref_update_pool.admin_state_up = data_models.UnsetType()
info = {
'id': self.ref_update_pool.pool_id,
'loadbalancer_id': self.ref_update_pool.loadbalancer_id,
'protocol': self.ref_pool.protocol
}
expected_dict = {'type': ovn_const.REQ_TYPE_POOL_UPDATE, 'info': info}
self.driver.pool_update(self.ref_pool, self.ref_update_pool)
self.mock_add_request.assert_called_once_with(expected_dict)
def test_member_update_unset_admin_state_up(self):
self.driver._ovn_helper._get_subnet_from_pool.return_value = (
self.ref_member.subnet_id)
self.update_member.admin_state_up = data_models.UnsetType()
info = {
'id': self.update_member.member_id,
'address': self.ref_member.address,
'protocol_port': self.ref_member.protocol_port,
'pool_id': self.ref_member.pool_id,
'old_admin_state_up': self.ref_member.admin_state_up,
'subnet_id': self.ref_member.subnet_id
}
expected_dict = {
'type': ovn_const.REQ_TYPE_MEMBER_UPDATE,
'info': info
}
member = copy.copy(self.ref_member)
member.subnet_id = data_models.UnsetType()
self.driver.member_update(member, self.update_member)
self.mock_add_request.assert_called_once_with(expected_dict)
def test_loadbalancer_create_unset_admin_state_up(self):
self.ref_lb0.admin_state_up = data_models.UnsetType()
info = {
'id': self.ref_lb0.loadbalancer_id,
'vip_address': self.ref_lb0.vip_address,
'vip_network_id': self.ref_lb0.vip_network_id,
'admin_state_up': True
}
expected_dict = {'type': ovn_const.REQ_TYPE_LB_CREATE, 'info': info}
calls = [mock.call(expected_dict)]
self.driver.loadbalancer_create(self.ref_lb0)
self.mock_add_request.assert_has_calls(calls)
def test_pool_create_unset_admin_state_up(self):
self.ref_pool.admin_state_up = data_models.UnsetType()
info = {
'id': self.ref_pool.pool_id,
'loadbalancer_id': self.ref_pool.loadbalancer_id,
'protocol': self.ref_pool.protocol,
'lb_algorithm': constants.LB_ALGORITHM_SOURCE_IP_PORT,
'listener_id': self.ref_pool.listener_id,
'admin_state_up': True
}
expected_dict = {'type': ovn_const.REQ_TYPE_POOL_CREATE, 'info': info}
self.driver.pool_create(self.ref_pool)
self.mock_add_request.assert_called_once_with(expected_dict)
def test_listener_update_unset_default_pool_id(self):
self.ref_listener.default_pool_id = data_models.UnsetType()
info = {
'id': self.ref_listener.listener_id,
'protocol_port': self.ref_listener.protocol_port,
'protocol': self.ref_pool.protocol,
'admin_state_up': self.ref_listener.admin_state_up,
'loadbalancer_id': self.ref_listener.loadbalancer_id
}
expected_dict = {
'type': ovn_const.REQ_TYPE_LISTENER_UPDATE,
'info': info
}
self.driver.listener_update(self.ref_listener, self.ref_listener)
self.mock_add_request.assert_called_once_with(expected_dict)
def test_health_monitor_update_unset_admin_state_up(self):
self.ref_update_health_monitor.admin_state_up = data_models.UnsetType()
info = {
'id': self.ref_update_health_monitor.healthmonitor_id,
'pool_id': self.ref_health_monitor.pool_id,
'interval': self.ref_update_health_monitor.delay,
'timeout': self.ref_update_health_monitor.timeout,
'failure_count': self.ref_update_health_monitor.max_retries_down,
'success_count': self.ref_update_health_monitor.max_retries,
'admin_state_up': True
}
expected_dict = {'type': ovn_const.REQ_TYPE_HM_UPDATE, 'info': info}
self.driver.health_monitor_update(self.ref_health_monitor,
self.ref_update_health_monitor)
self.mock_add_request.assert_called_once_with(expected_dict)
def test_member_create_no_set_admin_state_up(self):
self.ref_member.admin_state_up = data_models.UnsetType()
info = {
'id': self.ref_member.member_id,
'address': self.ref_member.address,
'protocol_port': self.ref_member.protocol_port,
'pool_id': self.ref_member.pool_id,
'subnet_id': self.ref_member.subnet_id,
'admin_state_up': True
}
expected_dict = {
'type': ovn_const.REQ_TYPE_MEMBER_CREATE,
'info': info
}
expected_dict_dvr = {
'type': ovn_const.REQ_TYPE_HANDLE_MEMBER_DVR,
'info': mock.ANY
}
expected = [mock.call(expected_dict), mock.call(expected_dict_dvr)]
self.driver.member_create(self.ref_member)
self.mock_add_request.assert_has_calls(expected)
def test_loadbalancer_update_unset_admin_state_up(self):
self.ref_lb1.admin_state_up = data_models.UnsetType()
info = {'id': self.ref_lb1.loadbalancer_id}
expected_dict = {'type': ovn_const.REQ_TYPE_LB_UPDATE, 'info': info}
self.driver.loadbalancer_update(self.ref_lb0, self.ref_lb1)
self.mock_add_request.assert_called_once_with(expected_dict)
def test_loadbalancer_create_member_without_subnet_id(self):
self.ref_member.subnet_id = data_models.UnsetType()
info = {
'id': self.ref_lb_fully_populated.loadbalancer_id,
'vip_address': self.ref_lb_fully_populated.vip_address,
'vip_network_id': self.ref_lb_fully_populated.vip_network_id,
'admin_state_up': self.ref_lb_fully_populated.admin_state_up
}
info_listener = {
'id': self.ref_listener.listener_id,
'protocol': self.ref_listener.protocol,
'protocol_port': self.ref_listener.protocol_port,
'default_pool_id': self.ref_listener.default_pool_id,
'admin_state_up': self.ref_listener.admin_state_up,
'loadbalancer_id': self.ref_listener.loadbalancer_id
}
info_pool = {
'id': self.ref_pool.pool_id,
'loadbalancer_id': self.ref_pool.loadbalancer_id,
'listener_id': self.ref_pool.listener_id,
'protocol': self.ref_pool.protocol,
'lb_algorithm': constants.LB_ALGORITHM_SOURCE_IP_PORT,
'admin_state_up': self.ref_pool.admin_state_up
}
info_member = {
'id': self.ref_member.member_id,
'address': self.ref_member.address,
'protocol_port': self.ref_member.protocol_port,
'pool_id': self.ref_member.pool_id,
'subnet_id': self.ref_lb_fully_populated.vip_network_id,
'admin_state_up': self.ref_member.admin_state_up
}
info_dvr = {
'id': self.ref_member.member_id,
'address': self.ref_member.address,
'pool_id': self.ref_member.pool_id,
'subnet_id': self.ref_lb_fully_populated.vip_network_id,
'action': ovn_const.REQ_INFO_MEMBER_ADDED
}
expected_lb_dict = {'type': ovn_const.REQ_TYPE_LB_CREATE, 'info': info}
expected_listener_dict = {
'type': ovn_const.REQ_TYPE_LISTENER_CREATE,
'info': info_listener
}
expected_pool_dict = {
'type': ovn_const.REQ_TYPE_POOL_CREATE,
'info': info_pool
}
expected_member_dict = {
'type': ovn_const.REQ_TYPE_MEMBER_CREATE,
'info': info_member
}
expected_dict_dvr = {
'type': ovn_const.REQ_TYPE_HANDLE_MEMBER_DVR,
'info': info_dvr
}
calls = [
mock.call(expected_lb_dict),
mock.call(expected_listener_dict),
mock.call(expected_pool_dict),
mock.call(expected_member_dict),
mock.call(expected_dict_dvr)
]
self.driver.loadbalancer_create(self.ref_lb_fully_populated)
self.mock_add_request.assert_has_calls(calls)
def test_member_batch_update_unset_admin_state_up(self):
self.ref_member.admin_state_up = data_models.UnsetType()
self.driver.member_batch_update(self.pool_id, [self.ref_member])
self.assertEqual(self.mock_add_request.call_count, 2)
def test_health_monitor_create_failure_unset_type(self):
self.fail_health_monitor.type = data_models.UnsetType()
self.assertRaises(exceptions.UnsupportedOptionError,
self.driver.health_monitor_create,
self.fail_health_monitor)