def test_find_pool(self): neutron = self.useFixture(k_fix.MockNeutronClient()).client cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) pool = obj_lbaas.LBaaSPool( name='TEST_NAME', project_id='TEST_PROJECT', protocol='TCP', listener_id='A57B7771-6050-4CA8-A63C-443493EC98AB', loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C') pool_id = 'D4F35594-27EB-4F4C-930C-31DD40F53B77' resp = { 'pools': [{ 'id': pool_id, 'listeners': [{ 'id': pool.listener_id }] }] } neutron.list_lbaas_pools.return_value = resp ret = cls._find_pool(m_driver, pool) neutron.list_lbaas_pools.assert_called_once_with( name=pool.name, project_id=pool.project_id, tenant_id=pool.project_id, loadbalancer_id=pool.loadbalancer_id, protocol=pool.protocol) for attr in pool.obj_fields: self.assertEqual(getattr(pool, attr), getattr(ret, attr)) self.assertEqual(pool_id, ret.id)
def test_find_member(self): neutron = self.useFixture(k_fix.MockNeutronClient()).client cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) member = obj_lbaas.LBaaSMember( name='TEST_NAME', project_id='TEST_PROJECT', ip='1.2.3.4', port=1234, subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1', pool_id='D4F35594-27EB-4F4C-930C-31DD40F53B77') member_id = '3A70CEC0-392D-4BC1-A27C-06E63A0FD54F' resp = {'members': [{'id': member_id}]} neutron.list_lbaas_members.return_value = resp ret = cls._find_member(m_driver, member) neutron.list_lbaas_members.assert_called_once_with( member.pool_id, name=member.name, project_id=member.project_id, tenant_id=member.project_id, subnet_id=member.subnet_id, address=member.ip, protocol_port=member.port) for attr in member.obj_fields: self.assertEqual(getattr(member, attr), getattr(ret, attr)) self.assertEqual(member_id, ret.id)
def test_create_pool_conflict(self): neutron = self.useFixture(k_fix.MockNeutronClient()).client cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) lb_algorithm = 'ROUND_ROBIN' pool = obj_lbaas.LBaaSPool( name='TEST_NAME', project_id='TEST_PROJECT', protocol='TCP', listener_id='A57B7771-6050-4CA8-A63C-443493EC98AB', loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C') req = { 'pool': { 'name': pool.name, 'project_id': pool.project_id, 'tenant_id': pool.project_id, 'listener_id': pool.listener_id, 'loadbalancer_id': pool.loadbalancer_id, 'protocol': pool.protocol, 'lb_algorithm': lb_algorithm } } neutron.create_lbaas_pool.side_effect = n_exc.StateInvalidClient self.assertRaises(n_exc.StateInvalidClient, cls._create_pool, m_driver, pool) neutron.create_lbaas_pool.assert_called_once_with(req) m_driver._cleanup_bogus_pool.assert_called_once_with( neutron, pool, lb_algorithm)
def test_request_vif(self, m_to_vif): cls = nested_macvlan_vif.NestedMacvlanPodVIFDriver m_driver = mock.Mock(spec=cls) neutron = self.useFixture(k_fix.MockNeutronClient()).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 = self._get_fake_port(mac_address=container_mac, ip_address=container_ip) vif = mock.Mock() port_request = mock.sentinel.port_request vm_port = self._get_fake_port() m_to_vif.return_value = vif m_driver._get_port_request.return_value = port_request m_driver._get_parent_port.return_value = vm_port m_driver.lock = mock.MagicMock(spec=threading.Lock()) neutron.create_port.return_value = container_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) neutron.create_port.assert_called_once_with(port_request) m_driver._get_parent_port.assert_called_once_with(neutron, pod) m_driver._add_to_allowed_address_pairs.assert_called_once_with( neutron, vm_port, frozenset([container_ip]), container_mac) m_to_vif.assert_called_once_with(container_port['port'], subnets)
def test_create_loadbalancer(self): neutron = self.useFixture(k_fix.MockNeutronClient()).client cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) loadbalancer = obj_lbaas.LBaaSLoadBalancer( name='TEST_NAME', project_id='TEST_PROJECT', ip='1.2.3.4', subnet_id='D3FA400A-F543-4B91-9CD3-047AF0CE42D1') loadbalancer_id = '00EE9E11-91C2-41CF-8FD4-7970579E5C4C' req = { 'loadbalancer': { 'name': loadbalancer.name, 'project_id': loadbalancer.project_id, 'tenant_id': loadbalancer.project_id, 'vip_address': str(loadbalancer.ip), 'vip_subnet_id': loadbalancer.subnet_id } } resp = {'loadbalancer': {'id': loadbalancer_id}} neutron.create_loadbalancer.return_value = resp ret = cls._create_loadbalancer(m_driver, loadbalancer) neutron.create_loadbalancer.assert_called_once_with(req) for attr in loadbalancer.obj_fields: self.assertEqual(getattr(loadbalancer, attr), getattr(ret, attr)) self.assertEqual(loadbalancer_id, ret.id)
def test_get_subnet(self, m_osv_subnet, m_osv_network): neutron = self.useFixture(k_fix.MockNeutronClient()).client subnet = mock.MagicMock() network = mock.MagicMock() subnet_id = mock.sentinel.subnet_id network_id = mock.sentinel.network_id neutron_subnet = {'network_id': network_id} neutron_network = mock.sentinel.neutron_network neutron.show_subnet.return_value = {'subnet': neutron_subnet} neutron.show_network.return_value = {'network': neutron_network} m_osv_subnet.return_value = subnet m_osv_network.return_value = network ret = default_subnet._get_subnet(subnet_id) self.assertEqual(network, ret) neutron.show_subnet.assert_called_once_with(subnet_id) neutron.show_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_request_vifs_exception(self, m_to_vif): cls = neutron_vif.NeutronPodVIFDriver m_driver = mock.Mock(spec=cls) neutron = self.useFixture(k_fix.MockNeutronClient()).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)]} neutron.create_port.side_effect = n_exc.NeutronClientException self.assertRaises(n_exc.NeutronClientException, 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) neutron.create_port.assert_called_once_with(bulk_rq) m_driver._get_vif_plugin.assert_not_called() m_to_vif.assert_not_called()
def test_release_vif_delete_failed(self): cls = nested_macvlan_vif.NestedMacvlanPodVIFDriver m_driver = mock.Mock(spec=cls) neutron = self.useFixture(k_fix.MockNeutronClient()).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 = self._get_fake_port(port_id, container_ip, container_mac) neutron.show_port.return_value = container_port neutron.delete_port.side_effect = n_exc.PortNotFoundClient vm_port = self._get_fake_port() m_driver._get_parent_port.return_value = vm_port m_driver.lock = mock.MagicMock(spec=threading.Lock()) cls.release_vif(m_driver, pod, vif) neutron.show_port.assert_called_once_with(port_id) m_driver._get_parent_port.assert_called_once_with(neutron, pod) m_driver._remove_from_allowed_address_pairs.assert_called_once_with( neutron, vm_port, frozenset([container_ip]), container_mac) neutron.delete_port.assert_called_once_with(vif.id)
def test_find_listener(self): neutron = self.useFixture(k_fix.MockNeutronClient()).client cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) listener = obj_lbaas.LBaaSListener( name='TEST_NAME', project_id='TEST_PROJECT', protocol='TCP', port=1234, loadbalancer_id='00EE9E11-91C2-41CF-8FD4-7970579E5C4C') listener_id = 'A57B7771-6050-4CA8-A63C-443493EC98AB' resp = {'listeners': [{'id': listener_id}]} neutron.list_listeners.return_value = resp ret = cls._find_listener(m_driver, listener) neutron.list_listeners.assert_called_once_with( name=listener.name, project_id=listener.project_id, tenant_id=listener.project_id, loadbalancer_id=listener.loadbalancer_id, protocol=listener.protocol, protocol_port=listener.port) for attr in listener.obj_fields: self.assertEqual(getattr(listener, attr), getattr(ret, attr)) self.assertEqual(listener_id, ret.id)
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() neutron = self.useFixture(k_fix.MockNeutronClient()).client floating_ip = { 'floating_ip_address': '1.2.3.4', 'port_id': None, 'id': 'a2a62ea7-e3bf-40df-8c09-aa0c29876a6b' } neutron.list_floatingips.return_value = {'floatingips': [floating_ip]} project_id = mock.sentinel.project_id spec_type = 'LoadBalancer' spec_lb_ip = '1.2.3.4' expected_resp = \ obj_lbaas.LBaaSPubIp(ip_id=floating_ip['id'], ip_addr=floating_ip['floating_ip_address'], alloc_method='user') self.assertEqual( expected_resp, cls.acquire_service_pub_ip_info(m_driver, spec_type, spec_lb_ip, project_id))
def test_request_vifs_no_vlans(self): cls = nested_vlan_vif.NestedVlanPodVIFDriver m_driver = mock.Mock(spec=cls) neutron = self.useFixture(k_fix.MockNeutronClient()).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(neutron, 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_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() neutron = self.useFixture(k_fix.MockNeutronClient()).client m_cfg.neutron_defaults.external_svc_subnet =\ mock.sentinel.external_svc_subnet neutron.show_subnet.return_value =\ {'subnet': {'network_id': 'ec29d641-fec4-4f67-928a-124a76b3a8e6'}} floating_ip = { 'floating_ip_address': '1.2.3.5', 'id': 'ec29d641-fec4-4f67-928a-124a76b3a888' } neutron.create_floatingip.return_value = {'floatingip': floating_ip} project_id = mock.sentinel.project_id spec_type = 'LoadBalancer' spec_lb_ip = None expected_resp = \ obj_lbaas.LBaaSPubIp(ip_id=floating_ip['id'], ip_addr=floating_ip['floating_ip_address'], alloc_method='pool') self.assertEqual( expected_resp, cls.acquire_service_pub_ip_info(m_driver, spec_type, spec_lb_ip, project_id))
def test_request_vif(self, m_to_vif): cls = neutron_vif.NeutronPodVIFDriver m_driver = mock.Mock(spec=cls) neutron = self.useFixture(k_fix.MockNeutronClient()).client pod = mock.sentinel.pod project_id = mock.sentinel.project_id subnets = mock.sentinel.subnets security_groups = mock.sentinel.security_groups port = mock.sentinel.port port_request = mock.sentinel.port_request vif = mock.sentinel.vif vif_plugin = mock.sentinel.vif_plugin m_to_vif.return_value = vif m_driver._get_port_request.return_value = port_request m_driver._get_vif_plugin.return_value = vif_plugin neutron.create_port.return_value = {'port': 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) neutron.create_port.assert_called_once_with(port_request) m_driver._get_vif_plugin.assert_called_once_with(port) 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 m_driver = mock.Mock(spec=cls) neutron = self.useFixture(k_fix.MockNeutronClient()).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 = self._get_fake_port(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()) neutron.create_port.return_value = container_port m_driver._get_parent_port.side_effect = n_exc.NeutronClientException self.assertRaises(n_exc.NeutronClientException, 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) neutron.create_port.assert_called_once_with(port_request) m_driver._get_parent_port.assert_called_once_with(neutron, pod) m_driver._add_to_allowed_address_pairs.assert_not_called() m_to_vif.assert_not_called()
def test_remove_from_allowed_address_pairs_missing(self, m_mac): cls = nested_macvlan_vif.NestedMacvlanPodVIFDriver m_driver = mock.Mock(spec=cls) neutron = self.useFixture(k_fix.MockNeutronClient()).client port_id = lib_utils.get_hash() vm_port = self._get_fake_port(port_id)['port'] 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}, ] mac_addr = m_mac if m_mac else vm_port['mac_address'] vm_port['allowed_address_pairs'].extend(address_pairs) vm_port['allowed_address_pairs'].append({'ip_address': '10.0.0.28', 'mac_address': mac_addr}) ip_addr = ['10.0.0.29', '10.0.0.28'] cls._remove_from_allowed_address_pairs( m_driver, neutron, vm_port, frozenset(ip_addr), m_mac) m_driver._update_port_address_pairs.assert_called_once_with( neutron, port_id, address_pairs)
def test_disassociate_neutron_exception(self): cls = d_public_ip.FipPubIpDriver m_driver = mock.Mock(spec=cls) res_id = mock.sentinel.res_id neutron = self.useFixture(k_fix.MockNeutronClient()).client neutron.update_floatingip.side_effect = n_exc.NeutronClientException self.assertIsNone(cls.disassociate(m_driver, res_id))
def test_request_vifs(self, m_to_vif): cls = nested_vlan_vif.NestedVlanPodVIFDriver m_driver = mock.Mock(spec=cls) neutron = self.useFixture(k_fix.MockNeutronClient()).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 = {'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) neutron.create_port.return_value = {'ports': [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(neutron, 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) neutron.create_port.assert_called_once_with(bulk_rq) neutron.trunk_add_subports.assert_called_once_with( trunk_id, {'sub_ports': subports_info}) neutron.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_disassociate_pub_ip_empty_param(self): cls = d_lb_public_ip.FloatingIpServicePubIPDriver m_driver = mock.Mock(spec=cls) neutron = self.useFixture(k_fix.MockNeutronClient()).client neutron.update_floatingip.return_value = None service_pub_ip_info = None self.assertIsNone( cls.disassociate_pub_ip(m_driver, service_pub_ip_info))
def test_disassociate_succeeded(self): cls = d_public_ip.FipPubIpDriver m_driver = mock.Mock(spec=cls) res_id = mock.sentinel.res_id neutron = self.useFixture(k_fix.MockNeutronClient()).client neutron.update_floatingip.return_value = None self.assertIsNone(cls.disassociate(m_driver, res_id))
def test_free_ip_neutron_exception(self): cls = d_public_ip.FipPubIpDriver m_driver = mock.Mock(spec=cls) res_id = mock.sentinel.res_id neutron = self.useFixture(k_fix.MockNeutronClient()).client neutron.delete_floatingip.side_effect = n_exc.NeutronClientException self.assertRaises(n_exc.NeutronClientException, cls.free_ip, m_driver, res_id)
def test_remove_from_allowed_address_pairs_no_ip_addresses(self): cls = nested_macvlan_vif.NestedMacvlanPodVIFDriver m_driver = mock.Mock(spec=cls) neutron = self.useFixture(k_fix.MockNeutronClient()).client port_id = lib_utils.get_hash() vm_port = self._get_fake_port(port_id)['port'] self.assertRaises(k_exc.IntegrityError, cls._remove_from_allowed_address_pairs, m_driver, neutron, vm_port, frozenset())
def test_release_vif(self): cls = neutron_vif.NeutronPodVIFDriver m_driver = mock.Mock(spec=cls) neutron = self.useFixture(k_fix.MockNeutronClient()).client pod = mock.sentinel.pod vif = mock.Mock() cls.release_vif(m_driver, pod, vif) neutron.delete_port.assert_called_once_with(vif.id)
def test_free_ip_succeeded(self): cls = d_public_ip.FipPubIpDriver m_driver = mock.Mock(spec=cls) res_id = mock.sentinel.res_id neutron = self.useFixture(k_fix.MockNeutronClient()).client neutron.delete_floatingip.return_value = None try: cls.free_ip(m_driver, res_id) except Exception: self.fail("Encountered an unexpected exception.")
def test_remove_subport(self): cls = nested_vlan_vif.NestedVlanPodVIFDriver m_driver = mock.Mock(spec=cls) neutron = self.useFixture(k_fix.MockNeutronClient()).client trunk_id = mock.sentinel.trunk_id subport_id = mock.sentinel.subport_id subportid_dict = [{'port_id': subport_id}] cls._remove_subport(m_driver, neutron, trunk_id, subport_id) neutron.trunk_remove_subports.assert_called_once_with( trunk_id, {'sub_ports': subportid_dict})
def test_get_parent_port_by_host_ip_subnet_id_not_configured(self): cls = nested_vif.NestedPodVIFDriver m_driver = mock.Mock(spec=cls) neutron = self.useFixture(k_fix.MockNeutronClient()).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, neutron, node_fixed_ip)
def test_is_ip_available_empty_fip_list(self): cls = d_public_ip.FipPubIpDriver m_driver = mock.Mock(spec=cls) neutron = self.useFixture(k_fix.MockNeutronClient()).client floating_ip = None neutron.list_floatingips.return_value = {'floatingips': [floating_ip]} fip_ip_addr = '1.1.1.1' fip_id = cls.is_ip_available(m_driver, fip_ip_addr) self.assertIsNone(fip_id)
def test_activate_vif_active(self): cls = neutron_vif.NeutronPodVIFDriver m_driver = mock.Mock(spec=cls) neutron = self.useFixture(k_fix.MockNeutronClient()).client pod = mock.sentinel.pod vif = mock.Mock() vif.active = True cls.activate_vif(m_driver, pod, vif) neutron.show_port.assert_not_called()
def test_add_subport_get_vlanid_failure(self): cls = nested_vlan_vif.NestedVlanPodVIFDriver m_driver = mock.Mock(spec=cls) neutron = self.useFixture(k_fix.MockNeutronClient()).client trunk_id = mock.sentinel.trunk_id subport = mock.sentinel.subport m_driver._get_vlan_id.side_effect = n_exc.NeutronClientException nested_vlan_vif.DEFAULT_MAX_RETRY_COUNT = 1 self.assertRaises(n_exc.NeutronClientException, cls._add_subport, m_driver, neutron, trunk_id, subport) m_driver._get_vlan_id.assert_called_once_with(trunk_id)
def test_is_ip_available_occupied_fip(self): cls = d_public_ip.FipPubIpDriver m_driver = mock.Mock(spec=cls) neutron = self.useFixture(k_fix.MockNeutronClient()).client floating_ip = { 'floating_ip_address': '1.2.3.4', 'port_id': 'ec29d641-fec4-4f67-928a-124a76b3a8e6' } neutron.list_floatingips.return_value = {'floatingips': [floating_ip]} fip_ip_addr = '1.2.3.4' fip_id = cls.is_ip_available(m_driver, fip_ip_addr) self.assertIsNone(fip_id)
def test_release_loadbalancer(self): neutron = self.useFixture(k_fix.MockNeutronClient()).client cls = d_lbaasv2.LBaaSv2Driver m_driver = mock.Mock(spec=d_lbaasv2.LBaaSv2Driver) endpoints = mock.sentinel.endpoints loadbalancer = mock.Mock() cls.release_loadbalancer(m_driver, endpoints, loadbalancer) m_driver._release.assert_called_once_with(loadbalancer, loadbalancer, neutron.delete_loadbalancer, loadbalancer.id)