def test_unplug_networks(self, mock_driver): def _interface(network_id): return [data_models.Interface(network_id=network_id)] net = network_tasks.UnPlugNetworks() net.execute(self.amphora_mock, None) self.assertFalse(mock_driver.unplug_network.called) delta = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=[], delete_nics=[]) net.execute(self.amphora_mock, delta) self.assertFalse(mock_driver.unplug_network.called) delta = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=[], delete_nics=_interface(1)) net.execute(self.amphora_mock, delta) mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1) mock_driver.reset_mock() mock_driver.unplug_network.side_effect = net_base.NetworkNotFound net.execute(self.amphora_mock, delta) # No exception mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1) # Do a test with a general exception in case behavior changes mock_driver.reset_mock() mock_driver.unplug_network.side_effect = Exception() net.execute(self.amphora_mock, delta) # No exception mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1)
def test_plug_networks(self, mock_get_net_driver): mock_driver = mock.MagicMock() mock_get_net_driver.return_value = mock_driver def _interface(network_id): return [data_models.Interface(network_id=network_id)] net = network_tasks.PlugNetworks() net.execute(self.amphora_mock, None) self.assertFalse(mock_driver.plug_network.called) delta = data_models.Delta(amphora_id=self.db_amphora_mock.id, compute_id=self.db_amphora_mock.compute_id, add_nics=[], delete_nics=[]).to_dict(recurse=True) net.execute(self.amphora_mock, delta) self.assertFalse(mock_driver.plug_network.called) delta = data_models.Delta(amphora_id=self.db_amphora_mock.id, compute_id=self.db_amphora_mock.compute_id, add_nics=_interface(1), delete_nics=[]).to_dict(recurse=True) net.execute(self.amphora_mock, delta) mock_driver.plug_network.assert_called_once_with(COMPUTE_ID, 1) # revert net.revert(self.amphora_mock, None) self.assertFalse(mock_driver.unplug_network.called) delta = data_models.Delta(amphora_id=self.db_amphora_mock.id, compute_id=self.db_amphora_mock.compute_id, add_nics=[], delete_nics=[]).to_dict(recurse=True) net.revert(self.amphora_mock, delta) self.assertFalse(mock_driver.unplug_network.called) delta = data_models.Delta(amphora_id=self.db_amphora_mock.id, compute_id=self.db_amphora_mock.compute_id, add_nics=_interface(1), delete_nics=[]).to_dict(recurse=True) net.revert(self.amphora_mock, delta) mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1) mock_driver.reset_mock() mock_driver.unplug_network.side_effect = net_base.NetworkNotFound net.revert(self.amphora_mock, delta) # No exception mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1) mock_driver.reset_mock() mock_driver.unplug_network.side_effect = TestException('test') self.assertRaises(TestException, net.revert, self.amphora_mock, delta) mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1)
def execute(self, loadbalancer, amphora): LOG.debug("Calculating network delta for amphora id: %s", amphora.id) # Figure out what networks we want # seed with lb network(s) vrrp_port = self.network_driver.get_port(amphora.vrrp_port_id) desired_network_ids = {vrrp_port.network_id}.union( CONF.controller_worker.amp_boot_network_list) for pool in loadbalancer.pools: member_networks = [ self.network_driver.get_subnet(member.subnet_id).network_id for member in pool.members if member.subnet_id ] desired_network_ids.update(member_networks) nics = self.network_driver.get_plugged_networks(amphora.compute_id) # assume we don't have two nics in the same network actual_network_nics = dict((nic.network_id, nic) for nic in nics) del_ids = set(actual_network_nics) - desired_network_ids delete_nics = list(actual_network_nics[net_id] for net_id in del_ids) add_ids = desired_network_ids - set(actual_network_nics) add_nics = list( n_data_models.Interface(network_id=net_id) for net_id in add_ids) delta = n_data_models.Delta(amphora_id=amphora.id, compute_id=amphora.compute_id, add_nics=add_nics, delete_nics=delete_nics) return delta
def execute(self, loadbalancer, amphora, availability_zone, vrrp_port=None): LOG.debug("Calculating network delta for amphora id: %s", amphora.get(constants.ID)) if vrrp_port is None: vrrp_port = self.network_driver.get_port( amphora[constants.VRRP_PORT_ID]) vrrp_port_network_id = vrrp_port.network_id else: vrrp_port_network_id = vrrp_port[constants.NETWORK_ID] # Figure out what networks we want # seed with lb network(s) if availability_zone: management_nets = ( [availability_zone.get(constants.MANAGEMENT_NETWORK)] or CONF.controller_worker.amp_boot_network_list) else: management_nets = CONF.controller_worker.amp_boot_network_list desired_network_ids = {vrrp_port_network_id}.union(management_nets) db_lb = self.loadbalancer_repo.get( db_apis.get_session(), id=loadbalancer[constants.LOADBALANCER_ID]) for pool in db_lb.pools: member_networks = [ self.network_driver.get_subnet(member.subnet_id).network_id for member in pool.members if member.subnet_id ] desired_network_ids.update(member_networks) nics = self.network_driver.get_plugged_networks( amphora[constants.COMPUTE_ID]) # assume we don't have two nics in the same network actual_network_nics = dict((nic.network_id, nic) for nic in nics) del_ids = set(actual_network_nics) - desired_network_ids delete_nics = list( n_data_models.Interface(network_id=net_id) for net_id in del_ids) add_ids = desired_network_ids - set(actual_network_nics) add_nics = list( n_data_models.Interface(network_id=net_id) for net_id in add_ids) delta = n_data_models.Delta(amphora_id=amphora[constants.ID], compute_id=amphora[constants.COMPUTE_ID], add_nics=add_nics, delete_nics=delete_nics) return delta.to_dict(recurse=True)
def execute(self, loadbalancers_list, amphora, member_list): LOG.debug("Calculating network delta for amphora id: %s", amphora.id) # Figure out what networks we want # seed with lb network(s) desired_network_ids = set( CONF.a10_controller_worker.amp_boot_network_list[:]) member_networks = [] for loadbalancer in loadbalancers_list: for pool in loadbalancer.pools: member_networks = [ self.network_driver.get_subnet(member.subnet_id).network_id for member in pool.members if member.subnet_id and member in member_list ] desired_network_ids.update(member_networks) loadbalancer_networks = [ self.network_driver.get_subnet( loadbalancer.vip.subnet_id).network_id for loadbalancer in loadbalancers_list if loadbalancer.vip.subnet_id ] desired_network_ids.update(loadbalancer_networks) LOG.debug("[NetIF] desired_network_ids.update{0}".format( desired_network_ids)) nics = self.network_driver.get_plugged_networks(amphora.compute_id) # assume we don't have two nics in the same network actual_network_nics = dict((nic.network_id, nic) for nic in nics) LOG.debug( "[NetIF] actual_network_nics {0}".format(actual_network_nics)) del_ids = set(actual_network_nics) - desired_network_ids delete_nics = list(actual_network_nics[net_id] for net_id in del_ids) add_ids = desired_network_ids - set(actual_network_nics) add_nics = list( n_data_models.Interface(network_id=net_id) for net_id in add_ids) delta = n_data_models.Delta(amphora_id=amphora.id, compute_id=amphora.compute_id, add_nics=add_nics, delete_nics=delete_nics) return delta
def execute(self, loadbalancer, amphora, availability_zone, vrrp_port=None): LOG.debug("Calculating network delta for amphora id: %s", amphora.id) if vrrp_port is None: vrrp_port = self.network_driver.get_port(amphora.vrrp_port_id) if availability_zone: management_nets = ( [availability_zone.get(constants.MANAGEMENT_NETWORK)] or CONF.controller_worker.amp_boot_network_list) else: management_nets = CONF.controller_worker.amp_boot_network_list desired_network_ids = {vrrp_port.network_id}.union(management_nets) for pool in loadbalancer.pools: member_networks = [ self.network_driver.get_subnet(member.subnet_id).network_id for member in pool.members if member.subnet_id ] desired_network_ids.update(member_networks) nics = self.network_driver.get_plugged_networks(amphora.compute_id) # assume we don't have two nics in the same network actual_network_nics = dict((nic.network_id, nic) for nic in nics) del_ids = set(actual_network_nics) - desired_network_ids delete_nics = list(actual_network_nics[net_id] for net_id in del_ids) add_ids = desired_network_ids - set(actual_network_nics) add_nics = list( n_data_models.Interface(network_id=net_id) for net_id in add_ids) delta = n_data_models.Delta(amphora_id=amphora.id, compute_id=amphora.compute_id, add_nics=add_nics, delete_nics=delete_nics) return delta
def execute(self, loadbalancer, amphora): LOG.debug("Calculating network delta for amphora id: %s", amphora.id) # Figure out what networks we want # seed with lb network(s) subnet = self.network_driver.get_subnet(loadbalancer.vip.subnet_id) desired_network_ids = { CONF.controller_worker.amp_network, subnet.network_id } if not loadbalancer.listeners: return None for listener in loadbalancer.listeners: if (not listener.default_pool) or ( not listener.default_pool.members): continue member_networks = [ self.network_driver.get_subnet(member.subnet_id).network_id for member in listener.default_pool.members if member.subnet_id ] desired_network_ids.update(member_networks) nics = self.network_driver.get_plugged_networks(amphora.compute_id) # assume we don't have two nics in the same network actual_network_nics = dict((nic.network_id, nic) for nic in nics) del_ids = set(actual_network_nics) - desired_network_ids delete_nics = list(actual_network_nics[net_id] for net_id in del_ids) add_ids = desired_network_ids - set(actual_network_nics) add_nics = list( n_data_models.Interface(network_id=net_id) for net_id in add_ids) delta = n_data_models.Delta(amphora_id=amphora.id, compute_id=amphora.compute_id, add_nics=add_nics, delete_nics=delete_nics) return delta
def test_handle_network_deltas(self, mock_get_net_driver): mock_driver = mock.MagicMock() self.db_amphora_mock.to_dict.return_value = { constants.ID: AMPHORA_ID, constants.COMPUTE_ID: COMPUTE_ID} mock_get_net_driver.return_value = mock_driver def _interface(network_id): return [data_models.Interface(network_id=network_id)] net = network_tasks.HandleNetworkDeltas() net.execute({}) self.assertFalse(mock_driver.plug_network.called) delta = data_models.Delta(amphora_id=self.db_amphora_mock.id, compute_id=self.db_amphora_mock.compute_id, add_nics=[], delete_nics=[]).to_dict(recurse=True) net.execute({self.db_amphora_mock.id: delta}) self.assertFalse(mock_driver.plug_network.called) delta = data_models.Delta(amphora_id=self.db_amphora_mock.id, compute_id=self.db_amphora_mock.compute_id, add_nics=_interface(1), delete_nics=[]).to_dict(recurse=True) net.execute({self.db_amphora_mock.id: delta}) mock_driver.plug_network.assert_called_once_with(COMPUTE_ID, 1) # revert net.execute({self.db_amphora_mock.id: delta}) self.assertFalse(mock_driver.unplug_network.called) delta = data_models.Delta(amphora_id=self.db_amphora_mock.id, compute_id=self.db_amphora_mock.compute_id, add_nics=[], delete_nics=[]).to_dict(recurse=True) net.execute({self.db_amphora_mock.id: delta}) self.assertFalse(mock_driver.unplug_network.called) delta = data_models.Delta(amphora_id=self.db_amphora_mock.id, compute_id=self.db_amphora_mock.compute_id, add_nics=_interface(1), delete_nics=[]).to_dict(recurse=True) mock_driver.reset_mock() mock_driver.unplug_network.side_effect = net_base.NetworkNotFound mock_driver.reset_mock() mock_driver.unplug_network.side_effect = TestException('test') self.assertRaises(TestException, net.revert, mock.ANY, {self.db_amphora_mock.id: delta}) mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1) mock_driver.reset_mock() net.execute({}) self.assertFalse(mock_driver.unplug_network.called) delta = data_models.Delta(amphora_id=self.db_amphora_mock.id, compute_id=self.db_amphora_mock.compute_id, add_nics=[], delete_nics=[]).to_dict(recurse=True) net.execute({self.db_amphora_mock.id: delta}) self.assertFalse(mock_driver.unplug_network.called) delta = data_models.Delta(amphora_id=self.db_amphora_mock.id, compute_id=self.db_amphora_mock.compute_id, add_nics=[], delete_nics=_interface(1) ).to_dict(recurse=True) net.execute({self.db_amphora_mock.id: delta}) mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1) mock_driver.reset_mock() mock_driver.unplug_network.side_effect = net_base.NetworkNotFound net.execute({self.db_amphora_mock.id: delta}) mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1) # Do a test with a general exception in case behavior changes mock_driver.reset_mock() mock_driver.unplug_network.side_effect = Exception() net.execute({self.db_amphora_mock.id: delta}) mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1)
def test_handle_network_delta(self, mock_get_net_driver): mock_net_driver = mock.MagicMock() self.db_amphora_mock.to_dict.return_value = { constants.ID: AMPHORA_ID, constants.COMPUTE_ID: COMPUTE_ID} mock_get_net_driver.return_value = mock_net_driver nic1 = data_models.Interface() nic1.network_id = uuidutils.generate_uuid() nic2 = data_models.Interface() nic2.network_id = uuidutils.generate_uuid() interface1 = mock.MagicMock() interface1.port_id = uuidutils.generate_uuid() port1 = mock.MagicMock() port1.network_id = uuidutils.generate_uuid() fixed_ip = mock.MagicMock() fixed_ip.subnet_id = uuidutils.generate_uuid() port1.fixed_ips = [fixed_ip] subnet = mock.MagicMock() network = mock.MagicMock() delta = data_models.Delta(amphora_id=self.db_amphora_mock.id, compute_id=self.db_amphora_mock.compute_id, add_nics=[nic1], delete_nics=[nic2, nic2, nic2] ).to_dict(recurse=True) mock_net_driver.plug_network.return_value = interface1 mock_net_driver.get_port.return_value = port1 mock_net_driver.get_network.return_value = network mock_net_driver.get_subnet.return_value = subnet mock_net_driver.unplug_network.side_effect = [ None, net_base.NetworkNotFound, Exception] handle_net_delta_obj = network_tasks.HandleNetworkDelta() result = handle_net_delta_obj.execute(self.amphora_mock, delta) mock_net_driver.plug_network.assert_called_once_with( self.db_amphora_mock.compute_id, nic1.network_id) mock_net_driver.get_port.assert_called_once_with(interface1.port_id) mock_net_driver.get_network.assert_called_once_with(port1.network_id) mock_net_driver.get_subnet.assert_called_once_with(fixed_ip.subnet_id) self.assertEqual({self.db_amphora_mock.id: [port1.to_dict()]}, result) mock_net_driver.unplug_network.assert_called_with( self.db_amphora_mock.compute_id, nic2.network_id) # Revert delta2 = data_models.Delta(amphora_id=self.db_amphora_mock.id, compute_id=self.db_amphora_mock.compute_id, add_nics=[nic1, nic1], delete_nics=[nic2, nic2, nic2] ).to_dict(recurse=True) mock_net_driver.unplug_network.reset_mock() handle_net_delta_obj.revert( failure.Failure.from_exception(Exception('boom')), None, None) mock_net_driver.unplug_network.assert_not_called() mock_net_driver.unplug_network.reset_mock() handle_net_delta_obj.revert(None, None, None) mock_net_driver.unplug_network.assert_not_called() mock_net_driver.unplug_network.reset_mock() handle_net_delta_obj.revert(None, None, delta2)
def test_calculate_delta(self, mock_get_session, mock_get_lb, mock_get_net_driver): mock_driver = mock.MagicMock() mock_get_lb.return_value = self.db_load_balancer_mock self.db_amphora_mock.to_dict.return_value = { constants.ID: AMPHORA_ID, constants.COMPUTE_ID: COMPUTE_ID, constants.VRRP_PORT_ID: PORT_ID} mock_get_net_driver.return_value = mock_driver mock_driver.get_plugged_networks.return_value = [ data_models.Interface(network_id='netid')] mock_driver.get_port.return_value = data_models.Port( network_id='netid') EMPTY = {} empty_deltas = {self.db_amphora_mock.id: data_models.Delta( amphora_id=AMPHORA_ID, compute_id=COMPUTE_ID, add_nics=[], delete_nics=[]).to_dict(recurse=True)} calc_delta = network_tasks.CalculateDelta() self.assertEqual(EMPTY, calc_delta.execute(self.load_balancer_mock, {})) # Test with one amp and no pools, nothing plugged # Delta should be empty mock_driver.reset_mock() self.db_amphora_mock.load_balancer = self.db_load_balancer_mock self.db_load_balancer_mock.amphorae = [self.db_amphora_mock] self.db_load_balancer_mock.pools = [] self.assertEqual(empty_deltas, calc_delta.execute(self.load_balancer_mock, {})) mock_driver.get_plugged_networks.assert_called_once_with(COMPUTE_ID) # Pool mock should be configured explicitly for each test pool_mock = mock.MagicMock() self.db_load_balancer_mock.pools = [pool_mock] # Test with one amp and one pool but no members, nothing plugged # Delta should be empty pool_mock.members = [] self.assertEqual(empty_deltas, calc_delta.execute(self.load_balancer_mock, {})) # Test with one amp and one pool and one member, nothing plugged # Delta should be one additional subnet to plug mock_driver.reset_mock() member_mock = mock.MagicMock() member_mock.subnet_id = 1 pool_mock.members = [member_mock] mock_driver.get_subnet.return_value = data_models.Subnet(id=2, network_id=3) ndm = data_models.Delta(amphora_id=self.db_amphora_mock.id, compute_id=self.db_amphora_mock.compute_id, add_nics=[ data_models.Interface(network_id=3)], delete_nics=[]).to_dict(recurse=True) self.assertEqual({self.db_amphora_mock.id: ndm}, calc_delta.execute(self.load_balancer_mock, {})) vrrp_port_call = mock.call(PORT_ID) mock_driver.get_port.assert_has_calls([vrrp_port_call]) self.assertEqual(1, mock_driver.get_port.call_count) member_subnet_call = mock.call(member_mock.subnet_id) mock_driver.get_subnet.assert_has_calls([member_subnet_call]) self.assertEqual(1, mock_driver.get_subnet.call_count) # Test with one amp and one pool and one member, already plugged # Delta should be empty mock_driver.reset_mock() member_mock = mock.MagicMock() member_mock.subnet_id = 1 pool_mock.members = [member_mock] mock_driver.get_plugged_networks.return_value = [ data_models.Interface(network_id=3), data_models.Interface(network_id='netid')] self.assertEqual(empty_deltas, calc_delta.execute(self.load_balancer_mock, {})) # Test with one amp and one pool and one member, wrong network plugged # Delta should be one network to add and one to remove mock_driver.reset_mock() member_mock = mock.MagicMock() member_mock.subnet_id = 1 pool_mock.members = [member_mock] mock_driver.get_plugged_networks.return_value = [ data_models.Interface(network_id=2), data_models.Interface(network_id='netid')] ndm = data_models.Delta(amphora_id=self.db_amphora_mock.id, compute_id=self.db_amphora_mock.compute_id, add_nics=[ data_models.Interface(network_id=3)], delete_nics=[ data_models.Interface(network_id=2)] ).to_dict(recurse=True) self.assertEqual({self.db_amphora_mock.id: ndm}, calc_delta.execute(self.load_balancer_mock, {})) # Test with one amp and one pool and no members, one network plugged # Delta should be one network to remove mock_driver.reset_mock() pool_mock.members = [] mock_driver.get_plugged_networks.return_value = [ data_models.Interface(network_id=2), data_models.Interface(network_id='netid') ] ndm = data_models.Delta(amphora_id=self.db_amphora_mock.id, compute_id=self.db_amphora_mock.compute_id, add_nics=[], delete_nics=[ data_models.Interface(network_id=2)] ).to_dict(recurse=True) self.assertEqual({self.db_amphora_mock.id: ndm}, calc_delta.execute(self.load_balancer_mock, {}))
def test_calculate_delta(self, mock_driver): EMPTY = {} empty_deltas = { self.amphora_mock.id: data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=[], delete_nics=[]) } def _interface(network_id): return [data_models.Interface(network_id=network_id)] net = network_tasks.CalculateDelta() self.assertEqual(EMPTY, net.execute(self.load_balancer_mock)) self.amphora_mock.load_balancer = self.load_balancer_mock self.load_balancer_mock.amphorae = [self.amphora_mock] self.load_balancer_mock.listeners = None self.assertEqual({self.amphora_mock.id: None}, net.execute(self.load_balancer_mock)) listener_mock = mock.MagicMock() self.load_balancer_mock.listeners = [listener_mock] listener_mock.default_pool = None self.assertEqual(empty_deltas, net.execute(self.load_balancer_mock)) mock_driver.get_plugged_networks.assert_called_once_with(COMPUTE_ID) pool_mock = mock.MagicMock() listener_mock.default_pool = pool_mock pool_mock.members = None self.assertEqual(empty_deltas, net.execute(self.load_balancer_mock)) member_mock = mock.MagicMock() pool_mock.members = [member_mock] member_mock.subnet_id = 1 mock_driver.get_subnet.reset_mock() mock_driver.get_subnet.return_value = data_models.Subnet(id=2, network_id=3) ndm = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=_interface(2), delete_nics=[]) self.assertEqual({self.amphora_mock.id: ndm}, net.execute(self.load_balancer_mock)) vip_subnet_call = mock.call(self.vip_mock.subnet_id) member_subnet_call = mock.call(member_mock.subnet_id) mock_driver.get_subnet.assert_has_calls( [vip_subnet_call, member_subnet_call]) self.assertEqual(2, mock_driver.get_subnet.call_count) mock_driver.get_plugged_networks.return_value = _interface(2) self.assertEqual(empty_deltas, net.execute(self.load_balancer_mock)) mock_driver.get_plugged_networks.return_value = _interface(3) ndm = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=_interface(2), delete_nics=_interface(3)) self.assertEqual({self.amphora_mock.id: ndm}, net.execute(self.load_balancer_mock)) pool_mock.members = [] mock_driver.get_plugged_networks.return_value = _interface(2) ndm = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=[], delete_nics=_interface(2)) self.assertEqual({self.amphora_mock.id: ndm}, net.execute(self.load_balancer_mock))
def test_handle_network_delta(self, mock_driver): def _interface(network_id): return [data_models.Interface(network_id=network_id)] net = network_tasks.HandleNetworkDeltas() net.execute({}) self.assertFalse(mock_driver.plug_network.called) delta = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=[], delete_nics=[]) net.execute({self.amphora_mock.id: delta}) self.assertFalse(mock_driver.plug_network.called) delta = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=_interface(1), delete_nics=[]) net.execute({self.amphora_mock.id: delta}) mock_driver.plug_network.assert_called_once_with(COMPUTE_ID, 1) # revert net.execute({self.amphora_mock.id: delta}) self.assertFalse(mock_driver.unplug_network.called) delta = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=[], delete_nics=[]) net.execute({self.amphora_mock.id: delta}) self.assertFalse(mock_driver.unplug_network.called) delta = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=_interface(1), delete_nics=[]) mock_driver.reset_mock() mock_driver.unplug_network.side_effect = net_base.NetworkNotFound mock_driver.reset_mock() mock_driver.unplug_network.side_effect = TestException('test') self.assertRaises(TestException, net.revert, mock.ANY, {self.amphora_mock.id: delta}) mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1) mock_driver.reset_mock() net.execute({}) self.assertFalse(mock_driver.unplug_network.called) delta = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=[], delete_nics=[]) net.execute({self.amphora_mock.id: delta}) self.assertFalse(mock_driver.unplug_network.called) delta = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=[], delete_nics=_interface(1)) net.execute({self.amphora_mock.id: delta}) mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1) mock_driver.reset_mock() mock_driver.unplug_network.side_effect = net_base.NetworkNotFound net.execute({self.amphora_mock.id: delta}) mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1) # Do a test with a general exception in case behavior changes mock_driver.reset_mock() mock_driver.unplug_network.side_effect = Exception() net.execute({self.amphora_mock.id: delta}) mock_driver.unplug_network.assert_called_once_with(COMPUTE_ID, 1)
def test_calculate_delta(self, mock_get_net_driver): mock_driver = mock.MagicMock() mock_get_net_driver.return_value = mock_driver EMPTY = {} empty_deltas = {self.amphora_mock.id: data_models.Delta( amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=[], delete_nics=[])} def _interface(network_id): return [data_models.Interface(network_id=network_id)] net = network_tasks.CalculateDelta() self.assertEqual(EMPTY, net.execute(self.load_balancer_mock)) self.amphora_mock.load_balancer = self.load_balancer_mock self.load_balancer_mock.amphorae = [self.amphora_mock] self.load_balancer_mock.pools = [] self.assertEqual(empty_deltas, net.execute(self.load_balancer_mock)) mock_driver.get_plugged_networks.assert_called_once_with(COMPUTE_ID) pool_mock = mock.MagicMock() self.load_balancer_mock.pools = [pool_mock] pool_mock.members = [] self.assertEqual(empty_deltas, net.execute(self.load_balancer_mock)) member_mock = mock.MagicMock() pool_mock.members = [member_mock] member_mock.subnet_id = 1 mock_driver.get_subnet.reset_mock() mock_driver.get_subnet.return_value = data_models.Subnet(id=2, network_id=3) ndm = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=_interface(2), delete_nics=[]) self.assertEqual({self.amphora_mock.id: ndm}, net.execute(self.load_balancer_mock)) vrrp_port_call = mock.call(self.amphora_mock.vrrp_port_id) mock_driver.get_port.assert_has_calls([vrrp_port_call]) # For some reason we call calculate_delta three times? self.assertEqual(3, mock_driver.get_port.call_count) member_subnet_call = mock.call(member_mock.subnet_id) mock_driver.get_subnet.assert_has_calls([member_subnet_call]) self.assertEqual(1, mock_driver.get_subnet.call_count) mock_driver.get_plugged_networks.return_value = _interface(2) self.assertEqual(empty_deltas, net.execute(self.load_balancer_mock)) mock_driver.get_plugged_networks.return_value = _interface(3) ndm = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=_interface(2), delete_nics=_interface(3)) self.assertEqual({self.amphora_mock.id: ndm}, net.execute(self.load_balancer_mock)) pool_mock.members = [] mock_driver.get_plugged_networks.return_value = _interface(2) ndm = data_models.Delta(amphora_id=self.amphora_mock.id, compute_id=self.amphora_mock.compute_id, add_nics=[], delete_nics=_interface(2)) self.assertEqual({self.amphora_mock.id: ndm}, net.execute(self.load_balancer_mock))