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())