def test_acquire_service_pub_ip_info_alloc_from_pool(self, m_cfg):
cls = d_lb_public_ip.FloatingIpServicePubIPDriver
m_driver = mock.Mock(spec=cls)
m_driver._drv_pub_ip = public_ip.FipPubIpDriver()
os_net = self.useFixture(k_fix.MockNetworkClient()).client
m_cfg.neutron_defaults.external_svc_subnet = (mock.sentinel
.external_svc_subnet)
os_net.get_subnet.return_value = munch.Munch(
{'network_id': 'ec29d641-fec4-4f67-928a-124a76b3a8e6'})
fip = munch.Munch({'floating_ip_address': '1.2.3.5',
'id': 'ec29d641-fec4-4f67-928a-124a76b3a888'})
os_net.create_ip.return_value = fip
project_id = mock.sentinel.project_id
spec_type = 'LoadBalancer'
spec_lb_ip = None
expected_resp = {
'ip_id': fip.id,
'ip_addr': fip.floating_ip_address,
'alloc_method': 'pool'
}
result = cls.acquire_service_pub_ip_info(m_driver, spec_type,
spec_lb_ip, project_id)
self.assertEqual(result, expected_resp)
def test_request_vif(self, m_to_vif):
cls = neutron_vif.NeutronPodVIFDriver
cls._tag_on_creation = True
m_driver = mock.Mock(spec=cls)
os_net = self.useFixture(k_fix.MockNetworkClient()).client
pod = mock.sentinel.pod
project_id = mock.sentinel.project_id
subnets = mock.sentinel.subnets
security_groups = mock.sentinel.security_groups
port = munch.Munch({'id': '910b1183-1f4a-450a-a298-0e80ad06ec8b'})
port_request = {'fake_req': mock.sentinel.port_request}
vif = mock.sentinel.vif
vif_plugin = mock.sentinel.vif_plugin
port.binding_vif_type = vif_plugin
m_to_vif.return_value = vif
m_driver._get_port_request.return_value = port_request
os_net.create_port.return_value = port
self.assertEqual(
vif,
cls.request_vif(m_driver, pod, project_id, subnets,
security_groups))
m_driver._get_port_request.assert_called_once_with(
pod, project_id, subnets, security_groups)
os_net.create_port.assert_called_once_with(**port_request)
m_to_vif.assert_called_once_with(vif_plugin, port, subnets)
def test_request_vif_parent_not_found(self, m_to_vif):
cls = nested_macvlan_vif.NestedMacvlanPodVIFDriver
cls._tag_on_creation = True
m_driver = mock.Mock(spec=cls)
os_net = self.useFixture(k_fix.MockNetworkClient()).client
pod = mock.sentinel.pod
project_id = mock.sentinel.project_id
subnets = mock.sentinel.subnets
security_groups = mock.sentinel.security_groups
container_mac = mock.sentinel.mac_address
container_ip = mock.sentinel.ip_address
container_port = fake.get_port_obj(mac_address=container_mac,
ip_address=container_ip)
port_request = mock.sentinel.port_request
m_driver._get_port_request.return_value = port_request
m_driver.lock = mock.MagicMock(spec=threading.Lock())
os_net.create_port.return_value = container_port
m_driver._get_parent_port.side_effect = o_exc.SDKException
self.assertRaises(o_exc.SDKException, cls.request_vif, m_driver, pod,
project_id, subnets, security_groups)
m_driver._get_port_request.assert_called_once_with(
pod, project_id, subnets, security_groups)
os_net.create_port.assert_not_called()
m_driver._get_parent_port.assert_called_once_with(pod)
m_driver._try_update_port.assert_not_called()
m_to_vif.assert_not_called()
def test_create_namespace_network(self):
cls = subnet_drv.NamespacePodSubnetDriver
m_driver = mock.MagicMock(spec=cls)
namespace = 'test'
project_id = mock.sentinel.project_id
os_net = self.useFixture(k_fix.MockNetworkClient()).client
net = munch.Munch({'id': mock.sentinel.net})
os_net.create_network.return_value = net
subnet = munch.Munch({'id': mock.sentinel.subnet,
'cidr': mock.sentinel.cidr})
os_net.create_subnet.return_value = subnet
os_net.add_interface_to_router.return_value = {}
router_id = 'router1'
oslo_cfg.CONF.set_override('pod_router',
router_id,
group='namespace_subnet')
net_crd = {'netId': net['id'],
'routerId': router_id,
'subnetId': subnet['id'],
'subnetCIDR': subnet['cidr']}
net_crd_resp = cls.create_namespace_network(m_driver, namespace,
project_id)
self.assertEqual(net_crd_resp, net_crd)
os_net.create_network.assert_called_once()
os_net.create_subnet.assert_called_once()
os_net.add_interface_to_router.assert_called_once()
def test_add_to_allowed_address_pairs_already_present(self):
cls = nested_macvlan_vif.NestedMacvlanPodVIFDriver
m_driver = mock.Mock(spec=cls)
self.useFixture(k_fix.MockNetworkClient()).client
port_id = lib_utils.get_hash()
vm_port = fake.get_port_obj(port_id)
address_pairs = [
{
'ip_address': '10.0.0.30',
'mac_address': 'fa:16:3e:1b:30:00'
},
{
'ip_address': 'fe80::f816:3eff:fe1c:36a9',
'mac_address': 'fa:16:3e:1b:30:00'
},
]
vm_port['allowed_address_pairs'].extend(address_pairs)
mac_addr = 'fa:16:3e:1b:30:00'
ip_addr = '10.0.0.30'
self.assertRaises(k_exc.AllowedAddressAlreadyPresent,
cls._add_to_allowed_address_pairs, m_driver, vm_port,
frozenset([ip_addr]), mac_addr)
def test_release_listener(self):
os_net = self.useFixture(k_fix.MockNetworkClient()).client
lbaas = self.useFixture(k_fix.MockLBaaSClient()).client
os_net.security_group_rules.return_value = (x for x in [])
cls = d_lbaasv2.LBaaSv2Driver
m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver)
m_driver._get_vip_port.return_value = munch.Munch(
{'security_group_ids': [mock.sentinel.sg_id]})
loadbalancer = {
'name': 'TEST_NAME',
'project_id': 'TEST_PROJECT',
'subnet_id': 'D3FA400A-F543-4B91-9CD3-047AF0CE42D1',
'ip': '1.2.3.4',
'id': '00EE9E11-91C2-41CF-8FD4-7970579E5C4C',
'security_groups': [],
'provider': 'amphora'
}
listener = {
'name': 'TEST_NAME',
'project_id': 'TEST_PROJECT',
'loadbalancer_id': '00EE9E11-91C2-41CF-8FD4-7970579E5C4C',
'protocol': 'TCP',
'port': 1234,
'id': 'A57B7771-6050-4CA8-A63C-443493EC98AB'
}
cls.release_listener(m_driver, loadbalancer, listener)
m_driver._release.assert_called_once_with(loadbalancer, listener,
lbaas.delete_listener,
listener['id'])
def test_get_nodes_ips_tagged(self):
CONF.set_override('resource_tags', ['foo'], group='neutron_defaults')
self.addCleanup(CONF.clear_override,
'resource_tags',
group='neutron_defaults')
os_net = self.useFixture(k_fix.MockNetworkClient()).client
ip1 = munch.Munch({
'fixed_ips': [{
'ip_address': '10.0.0.1',
'subnet_id': 'foo'
}],
'trunk_details':
True
})
ip2 = munch.Munch({
'fixed_ips': [{
'ip_address': '10.0.0.2',
'subnet_id': 'bar'
}],
'trunk_details':
False
})
ports = (p for p in [ip1, ip2])
os_net.ports.return_value = ports
trunk_ips = utils.get_nodes_ips(['foo'])
os_net.ports.assert_called_once_with(status='ACTIVE', tags=['foo'])
self.assertEqual(trunk_ips, [ip1.fixed_ips[0]['ip_address']])
def test_try_update_port(self, aaapf_mock):
cls = nested_macvlan_vif.NestedMacvlanPodVIFDriver
m_driver = mock.Mock(spec=cls)
m_driver.lock = mock.MagicMock(spec=threading.Lock())
self.useFixture(k_fix.MockNetworkClient()).client
port_id = lib_utils.get_hash()
vm_port = fake.get_port_obj(port_id)
mac_addr = 'fa:16:3e:1b:30:00'
address_pairs = [
{
'ip_address': '10.0.0.30',
'mac_address': mac_addr
},
{
'ip_address': 'fe80::f816:3eff:fe1c:36a9',
'mac_address': mac_addr
},
]
vm_port['allowed_address_pairs'].extend(address_pairs)
ip_addr = ['10.0.0.29']
attempts = cls._try_update_port(m_driver, 3,
cls._add_to_allowed_address_pairs,
vm_port, frozenset(ip_addr), mac_addr)
self.assertEqual(attempts, 0)
aaapf_mock.assert_called_once()
def test_get_nodes_ips(self):
os_net = self.useFixture(k_fix.MockNetworkClient()).client
ip1 = munch.Munch({
'fixed_ips': [{
'ip_address': '10.0.0.1'
}],
'trunk_details': True
})
ip2 = munch.Munch({
'fixed_ips': [{
'ip_address': '10.0.0.2'
}],
'trunk_details': True
})
ip3 = munch.Munch({
'fixed_ips': [{
'ip_address': '10.0.0.3'
}],
'trunk_details': None
})
ports = (p for p in [ip1, ip2, ip3])
os_net.ports.return_value = ports
trunk_ips = utils.get_nodes_ips()
os_net.ports.assert_called_once_with(status='ACTIVE')
self.assertEqual(
trunk_ips,
[ip1.fixed_ips[0]['ip_address'], ip2.fixed_ips[0]['ip_address']])
def test_request_vifs_no_vlans(self):
cls = nested_vlan_vif.NestedVlanPodVIFDriver
m_driver = mock.Mock(spec=cls)
self.useFixture(k_fix.MockNetworkClient()).client
pod = mock.sentinel.pod
project_id = mock.sentinel.project_id
subnets = mock.sentinel.subnets
security_groups = mock.sentinel.security_groups
num_ports = 2
parent_port = mock.sentinel.parent_port
trunk_id = mock.sentinel.trunk_id
port_request = mock.sentinel.port_request
subports_info = []
m_driver._get_parent_port.return_value = parent_port
m_driver._get_trunk_id.return_value = trunk_id
m_driver._create_subports_info.return_value = (port_request,
subports_info)
self.assertEqual([],
cls.request_vifs(m_driver, pod, project_id, subnets,
security_groups, num_ports))
m_driver._get_parent_port.assert_called_once_with(pod)
m_driver._get_trunk_id.assert_called_once_with(parent_port)
m_driver._create_subports_info.assert_called_once_with(pod,
project_id,
subnets,
security_groups,
trunk_id,
num_ports,
unbound=True)
def test_request_vif(self, m_to_vif, m_to_fips):
cls = drvs.SriovVIFDriver
m_driver = mock.Mock(spec=cls)
os_net = self.useFixture(k_fix.MockNetworkClient()).client
project_id = mock.sentinel.project_id
fixed_ips = mock.sentinel.fixed_ips
m_to_fips.return_value = fixed_ips
network = mock.sentinel.Network
subnet_id = str(uuid.uuid4())
subnets = {subnet_id: network}
security_groups = mock.sentinel.security_groups
port_fixed_ips = mock.sentinel.port_fixed_ips
port_id = mock.sentinel.port_id
port = {'fixed_ips': port_fixed_ips, 'id': port_id}
port_request = {'fake_req': mock.sentinel.port_request}
m_driver._get_port_request.return_value = port_request
vif = mock.sentinel.vif
m_to_vif.return_value = vif
os_net.create_port.return_value = port
utils.get_subnet.return_value = subnets
self.assertEqual(
vif,
cls.request_vif(m_driver, self._pod, project_id, subnets,
security_groups))
os_net.create_port.assert_called_once_with(**port_request)
def test_try_update_port_failure(self, aaapf_mock):
cls = nested_macvlan_vif.NestedMacvlanPodVIFDriver
m_driver = mock.Mock(spec=cls)
m_driver.lock = mock.MagicMock(spec=threading.Lock())
self.useFixture(k_fix.MockNetworkClient()).client
port_id = lib_utils.get_hash()
vm_port = fake.get_port_obj(port_id)
mac_addr = 'fa:16:3e:1b:30:00'
address_pairs = [
{
'ip_address': '10.0.0.30',
'mac_address': mac_addr
},
{
'ip_address': 'fe80::f816:3eff:fe1c:36a9',
'mac_address': mac_addr
},
]
vm_port['allowed_address_pairs'].extend(address_pairs)
ip_addr = ['10.0.0.29']
aaapf_mock.side_effect = o_exc.SDKException
self.assertRaises(o_exc.SDKException, cls._try_update_port, m_driver,
1, cls._add_to_allowed_address_pairs, vm_port,
frozenset(ip_addr), mac_addr)
def test_request_vifs_exception(self, m_to_vif):
cls = neutron_vif.NeutronPodVIFDriver
cls._tag_on_creation = False
m_driver = mock.Mock(spec=cls)
os_net = self.useFixture(k_fix.MockNetworkClient()).client
pod = mock.sentinel.pod
project_id = mock.sentinel.project_id
subnets = mock.sentinel.subnets
security_groups = mock.sentinel.security_groups
num_ports = 2
port_request = mock.sentinel.port_request
m_driver._get_port_request.return_value = port_request
bulk_rq = {'ports': [port_request for _ in range(num_ports)]}
os_net.create_ports.side_effect = os_exc.SDKException
self.assertRaises(os_exc.SDKException, cls.request_vifs, m_driver, pod,
project_id, subnets, security_groups, num_ports)
m_driver._get_port_request.assert_called_once_with(pod,
project_id,
subnets,
security_groups,
unbound=True)
os_net.create_ports.assert_called_once_with(bulk_rq)
m_to_vif.assert_not_called()
def test_ensure_loadbalancer(self):
os_net = self.useFixture(k_fix.MockNetworkClient()).client
cls = d_lbaasv2.LBaaSv2Driver
m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver)
expected_resp = obj_lbaas.LBaaSLoadBalancer(
provider='octavia', port_id='D3FA400A-F543-4B91-9CD3-047AF0CE42E2',
security_groups=[])
project_id = 'TEST_PROJECT'
subnet_id = 'D3FA400A-F543-4B91-9CD3-047AF0CE42D1'
ip = '1.2.3.4'
sg_ids = ['foo', 'bar']
lb_name = 'just_a_name'
m_driver._ensure.return_value = expected_resp
os_net.update_port = mock.Mock()
resp = cls.ensure_loadbalancer(m_driver, lb_name, project_id,
subnet_id, ip, sg_ids, 'ClusterIP')
m_driver._ensure.assert_called_once_with(mock.ANY,
m_driver._create_loadbalancer,
m_driver._find_loadbalancer)
req = m_driver._ensure.call_args[0][0]
self.assertEqual(lb_name, req.name)
self.assertEqual(project_id, req.project_id)
self.assertEqual(subnet_id, req.subnet_id)
self.assertEqual(ip, str(req.ip))
self.assertEqual(expected_resp, resp)
os_net.update_port.assert_not_called()
def test_add_to_allowed_address_pairs_same_ip(self):
cls = nested_macvlan_vif.NestedMacvlanPodVIFDriver
m_driver = mock.Mock(spec=cls)
self.useFixture(k_fix.MockNetworkClient()).client
port_id = lib_utils.get_hash()
vm_port = fake.get_port_obj(port_id)
address_pairs = [
{
'ip_address': '10.0.0.30',
'mac_address': 'fa:16:3e:1b:30:00'
},
{
'ip_address': 'fe80::f816:3eff:fe1c:36a9',
'mac_address': 'fa:16:3e:1b:30:00'
},
]
vm_port['allowed_address_pairs'].extend(address_pairs)
mac_addr = 'fa:16:3e:71:cb:80'
ip_addr = '10.0.0.30'
address_pairs.append({'ip_address': ip_addr, 'mac_address': mac_addr})
cls._add_to_allowed_address_pairs(m_driver, vm_port,
frozenset([ip_addr]), mac_addr)
m_driver._update_port_address_pairs.assert_called_once_with(
port_id, address_pairs, revision_number=9)
def test_release_vif_delete_failed(self):
cls = nested_macvlan_vif.NestedMacvlanPodVIFDriver
m_driver = mock.Mock(spec=cls)
os_net = self.useFixture(k_fix.MockNetworkClient()).client
port_id = lib_utils.get_hash()
pod = mock.sentinel.pod
vif = mock.Mock()
vif.id = port_id
container_mac = mock.sentinel.mac_address
container_ip = mock.sentinel.ip_addresses
container_port = fake.get_port_obj(port_id=port_id,
ip_address=container_ip,
mac_address=container_mac)
os_net.get_port.return_value = container_port
os_net.delete_port.side_effect = o_exc.NotFoundException
vm_port = fake.get_port_obj()
m_driver._get_parent_port.return_value = vm_port
m_driver._try_update_port.return_value = 0
m_driver.lock = mock.MagicMock(spec=threading.Lock())
cls.release_vif(m_driver, pod, vif)
os_net.get_port.assert_called_once_with(port_id)
m_driver._get_parent_port.assert_called_once_with(pod)
m_driver._try_update_port.assert_called_once()
os_net.delete_port.assert_called_once_with(vif.id,
ignore_missing=False)
def test_get_parent_port_by_host_ip_multiple(self):
cls = nested_vif.NestedPodVIFDriver
m_driver = mock.Mock(
spec=cls, nodes_subnets_driver=node_subnets.ConfigNodesSubnets())
os_net = self.useFixture(k_fix.MockNetworkClient()).client
node_subnet_id1 = 'node_subnet_id1'
node_subnet_id2 = 'node_subnet_id2'
node_subnet_id3 = 'node_subnet_id3'
oslo_cfg.CONF.set_override('worker_nodes_subnets',
[node_subnet_id3, node_subnet_id2],
group='pod_vif_nested')
node_fixed_ip = mock.sentinel.node_fixed_ip
ports = [
mock.Mock(fixed_ips=[{'subnet_id': node_subnet_id1}]),
mock.Mock(fixed_ips=[{'subnet_id': node_subnet_id2}]),
]
os_net.ports.return_value = (p for p in ports)
self.assertEqual(ports[1], cls._get_parent_port_by_host_ip(
m_driver, node_fixed_ip))
fixed_ips = ['ip_address=%s' % str(node_fixed_ip)]
os_net.ports.assert_called_with(fixed_ips=fixed_ips)
def test_remove_from_allowed_address_pairs_no_update(self, m_mac):
cls = nested_macvlan_vif.NestedMacvlanPodVIFDriver
m_driver = mock.Mock(spec=cls)
self.useFixture(k_fix.MockNetworkClient()).client
port_id = lib_utils.get_hash()
vm_port = fake.get_port_obj(port_id)
mac_addr = 'fa:16:3e:1b:30:00' if m_mac else vm_port['mac_address']
address_pairs = [
{
'ip_address': '10.0.0.30',
'mac_address': mac_addr
},
{
'ip_address': 'fe80::f816:3eff:fe1c:36a9',
'mac_address': mac_addr
},
]
vm_port['allowed_address_pairs'].extend(address_pairs)
ip_addr = ['10.0.0.29']
cls._remove_from_allowed_address_pairs(m_driver, vm_port,
frozenset(ip_addr), m_mac)
m_driver._update_port_address_pairs.assert_not_called()
def test_release_vif_parent_not_found(self):
cls = nested_macvlan_vif.NestedMacvlanPodVIFDriver
m_driver = mock.Mock(spec=cls)
os_net = self.useFixture(k_fix.MockNetworkClient()).client
port_id = lib_utils.get_hash()
pod = mock.sentinel.pod
vif = mock.Mock()
vif.id = port_id
container_mac = mock.sentinel.mac_address
container_ip = mock.sentinel.ip_address
container_port = fake.get_port_obj(port_id=port_id,
ip_address=container_ip,
mac_address=container_mac)
os_net.get_port.return_value = container_port
m_driver.lock = mock.MagicMock(spec=threading.Lock())
m_driver._get_parent_port.side_effect = o_exc.SDKException
self.assertRaises(o_exc.SDKException, cls.release_vif, m_driver, pod,
vif)
os_net.get_port.assert_called_with(port_id)
self.assertEqual(os_net.get_port.call_count, 1)
m_driver._get_parent_port.assert_called_with(pod)
self.assertEqual(m_driver._get_parent_port.call_count, 1)
m_driver._remove_from_allowed_address_pairs.assert_not_called()
os_net.delete_port.assert_not_called()
def test_get_subnet(self, m_osv_subnet, m_osv_network):
os_net = self.useFixture(k_fix.MockNetworkClient()).client
subnet = mock.MagicMock()
network = mock.MagicMock()
subnet_id = mock.sentinel.subnet_id
network_id = mock.sentinel.network_id
neutron_subnet = munch.Munch({'network_id': network_id})
neutron_network = mock.sentinel.neutron_network
os_net.get_subnet.return_value = neutron_subnet
os_net.get_network.return_value = neutron_network
m_osv_subnet.return_value = subnet
m_osv_network.return_value = network
ret = utils.get_subnet(subnet_id)
self.assertEqual(network, ret)
os_net.get_subnet.assert_called_once_with(subnet_id)
os_net.get_network.assert_called_once_with(network_id)
m_osv_subnet.assert_called_once_with(neutron_subnet)
m_osv_network.assert_called_once_with(neutron_network)
network.subnets.objects.append.assert_called_once_with(subnet)
def test_acquire_service_pub_ip_info_usr_specified_ip(self):
cls = d_lb_public_ip.FloatingIpServicePubIPDriver
m_driver = mock.Mock(spec=cls)
m_driver._drv_pub_ip = public_ip.FipPubIpDriver()
os_net = self.useFixture(k_fix.MockNetworkClient()).client
fip = munch.Munch({'floating_ip_address': '1.2.3.4',
'port_id': None,
'id': 'a2a62ea7-e3bf-40df-8c09-aa0c29876a6b'})
os_net.ips.return_value = (ip for ip in [fip])
project_id = mock.sentinel.project_id
spec_type = 'LoadBalancer'
spec_lb_ip = '1.2.3.4'
CONF.set_override('external_svc_net',
'9767e1bd-40a7-4294-8e59-29dd77edb0e3',
group='neutron_defaults')
expected_resp = {
'ip_id': fip.id,
'ip_addr': fip.floating_ip_address,
'alloc_method': 'user'
}
result = cls.acquire_service_pub_ip_info(m_driver, spec_type,
spec_lb_ip, project_id)
self.assertEqual(result, expected_resp)
def test_request_vifs(self, m_to_vif):
cls = nested_vlan_vif.NestedVlanPodVIFDriver
cls._tag_on_creation = True
m_driver = mock.Mock(spec=cls)
os_net = self.useFixture(k_fix.MockNetworkClient()).client
pod = mock.sentinel.pod
project_id = mock.sentinel.project_id
subnets = mock.sentinel.subnets
security_groups = mock.sentinel.security_groups
num_ports = 2
parent_port = mock.sentinel.parent_port
trunk_id = mock.sentinel.trunk_id
port_request = mock.sentinel.port_request
subports_info = [{
'segmentation_id': 1,
'port_id': '',
'segmentation_type': 'vlan'
}, {
'segmentation_id': 2,
'port_id': '',
'segmentation_type': 'vlan'
}]
port = munch.Munch({'id': mock.sentinel.id})
vif = mock.sentinel.vif
bulk_rq = {'ports': [port_request for _ in range(len(subports_info))]}
m_driver._get_parent_port.return_value = parent_port
m_driver._get_trunk_id.return_value = trunk_id
m_driver._create_subports_info.return_value = (port_request,
subports_info)
os_net.create_ports.return_value = (p for p in [port, port])
m_to_vif.return_value = vif
self.assertEqual([vif, vif],
cls.request_vifs(m_driver, pod, project_id, subnets,
security_groups, num_ports))
m_driver._get_parent_port.assert_called_once_with(pod)
m_driver._get_trunk_id.assert_called_once_with(parent_port)
m_driver._create_subports_info.assert_called_once_with(pod,
project_id,
subnets,
security_groups,
trunk_id,
num_ports,
unbound=True)
os_net.create_ports.assert_called_once_with(bulk_rq)
os_net.add_trunk_subports.assert_called_once_with(
trunk_id, subports_info)
os_net.delete_port.assert_not_called()
calls = [
mock.call(port, subnets, info['segmentation_id'])
for info in subports_info
]
m_to_vif.assert_has_calls(calls)
def test_get_subnet_cidr_no_such_subnet(self):
os_net = self.useFixture(k_fix.MockNetworkClient()).client
subnet_id = mock.sentinel.subnet_id
os_net.get_subnet.side_effect = os_exc.ResourceNotFound
self.assertRaises(os_exc.ResourceNotFound, utils.get_subnet_cidr,
subnet_id)
os_net.get_subnet.assert_called_once_with(subnet_id)
def test_get_subnet_cidr(self):
os_net = self.useFixture(k_fix.MockNetworkClient()).client
subnet_id = mock.sentinel.subnet_id
subnet = munch.Munch(cidr='10.0.0.0/24')
os_net.get_subnet.return_value = subnet
result = utils.get_subnet_cidr(subnet_id)
os_net.get_subnet.assert_called_once_with(subnet_id)
self.assertEqual(result, '10.0.0.0/24')
def test_disassociate_pub_ip_empty_param(self):
cls = d_lb_public_ip.FloatingIpServicePubIPDriver
m_driver = mock.Mock(spec=cls)
self.useFixture(k_fix.MockNetworkClient()).client
service_pub_ip_info = None
result = cls.disassociate_pub_ip(m_driver, service_pub_ip_info)
self.assertIsNone(result)
def setUp(self):
super(TestControllerPrometheusExporter, self).setUp()
self.cls = prometheus_exporter.ControllerPrometheusExporter
self.srv = mock.MagicMock(spec=self.cls)
self.srv.quota_free_count = mock.MagicMock(
spec=prometheus_client.Gauge)
self.srv.port_quota_per_subnet = mock.MagicMock(
spec=prometheus_client.Gauge)
self.srv._project_id = mock.sentinel.project_id
self.srv._os_net = self.useFixture(k_fix.MockNetworkClient()).client
def test_associate_conflict_correct(self):
driver = d_public_ip.FipPubIpDriver()
res_id = mock.sentinel.res_id
vip_port_id = mock.sentinel.vip_port_id
os_net = self.useFixture(k_fix.MockNetworkClient()).client
os_net.update_ip.side_effect = os_exc.ConflictException
os_net.get_ip.return_value = munch.Munch({'id': res_id,
'port_id': vip_port_id})
self.assertIsNone(driver.associate(res_id, vip_port_id))
def test__components_ready_error(self, m_status):
os_net = self.useFixture(k_fix.MockNetworkClient()).client
os_net.get_quota.return_value = get_quota_obj()
self.srv._registry = [_TestHandler()]
m_status.return_value = False
resp = self.srv._components_ready()
m_status.assert_called_once()
self.assertIs(resp, False)
os_net.get_quota.assert_called_once()
def test_get_parent_port_by_host_ip_subnet_id_not_configured(self):
cls = nested_vif.NestedPodVIFDriver
m_driver = mock.Mock(spec=cls)
self.useFixture(k_fix.MockNetworkClient()).client
oslo_cfg.CONF.set_override('worker_nodes_subnet',
'',
group='pod_vif_nested')
node_fixed_ip = mock.sentinel.node_fixed_ip
self.assertRaises(oslo_cfg.RequiredOptError,
cls._get_parent_port_by_host_ip, m_driver,
node_fixed_ip)
def test_remove_from_allowed_address_pairs_no_ip_addresses(self):
cls = nested_macvlan_vif.NestedMacvlanPodVIFDriver
m_driver = mock.Mock(spec=cls)
self.useFixture(k_fix.MockNetworkClient()).client
port_id = lib_utils.get_hash()
vm_port = fake.get_port_obj(port_id)
self.assertRaises(k_exc.IntegrityError,
cls._remove_from_allowed_address_pairs, m_driver,
vm_port, frozenset())
