# Copyright 2012 VMware, Inc. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import contextlib import mock from neutron.api import extensions from neutron.api.v2 import attributes from neutron.db import api as db_api from neutron.db import db_base_plugin_v2 from neutron import quota from neutron.tests import base from neutron.tests.unit.api import test_extensions from neutron.tests.unit.api.v2 import test_base from neutron.tests.unit.db import test_db_base_plugin_v2 as test_db_plugin from neutron_lib import context from neutron_lib.plugins import constants from neutron_lib.plugins import directory from oslo_config import cfg from webob import exc import webtest from vmware_nsx.api_client import exception as api_exc from vmware_nsx.common import exceptions as nsx_exc from vmware_nsx.db import networkgw_db from vmware_nsx.db import nsx_models from vmware_nsx.extensions import networkgw from vmware_nsx.nsxlib import mh as nsxlib from vmware_nsx.nsxlib.mh import l2gateway as l2gwlib from vmware_nsx.tests import unit as vmware from vmware_nsx.tests.unit.nsx_mh import test_plugin as test_nsx_plugin _uuid = test_base._uuid _get_path = test_base._get_path class TestExtensionManager(object): def get_resources(self): # Add the resources to the global attribute map # This is done here as the setup process won't # initialize the main API router which extends # the global attribute map attributes.RESOURCE_ATTRIBUTE_MAP.update( networkgw.RESOURCE_ATTRIBUTE_MAP) return networkgw.Networkgw.get_resources() def get_actions(self): return [] def get_request_extensions(self): return [] class NetworkGatewayExtensionTestCase(base.BaseTestCase): def setUp(self): super(NetworkGatewayExtensionTestCase, self).setUp() plugin = '%s.%s' % (networkgw.__name__, networkgw.NetworkGatewayPluginBase.__name__) self._gw_resource = networkgw.GATEWAY_RESOURCE_NAME self._dev_resource = networkgw.DEVICE_RESOURCE_NAME # Ensure existing ExtensionManager is not used extensions.PluginAwareExtensionManager._instance = None # Create the default configurations self.config_parse() # Update the plugin and extensions path self.setup_coreplugin(plugin) _plugin_patcher = mock.patch(plugin, autospec=True) self.plugin = _plugin_patcher.start() # Instantiate mock plugin and enable extensions self.plugin.return_value.supported_extension_aliases = ( [networkgw.EXT_ALIAS]) directory.add_plugin(constants.CORE, self.plugin.return_value) ext_mgr = TestExtensionManager() extensions.PluginAwareExtensionManager._instance = ext_mgr self.ext_mdw = test_extensions.setup_extensions_middleware(ext_mgr) self.api = webtest.TestApp(self.ext_mdw) quota.QUOTAS._driver = None cfg.CONF.set_override('quota_driver', 'neutron.quota.ConfDriver', group='QUOTAS') def test_network_gateway_create(self): nw_gw_id = _uuid() tenant_id = _uuid() data = {self._gw_resource: {'name': 'nw-gw', 'tenant_id': tenant_id, 'project_id': tenant_id, 'devices': [{'id': _uuid(), 'interface_name': 'xxx'}]}} return_value = data[self._gw_resource].copy() return_value.update({'id': nw_gw_id}) instance = self.plugin.return_value instance.create_network_gateway.return_value = return_value res = self.api.post_json(_get_path(networkgw.NETWORK_GATEWAYS), data) instance.create_network_gateway.assert_called_with( mock.ANY, network_gateway=data) self.assertEqual(res.status_int, exc.HTTPCreated.code) self.assertIn(self._gw_resource, res.json) nw_gw = res.json[self._gw_resource] self.assertEqual(nw_gw['id'], nw_gw_id) def _test_network_gateway_create_with_error( self, data, error_code=exc.HTTPBadRequest.code): res = self.api.post_json(_get_path(networkgw.NETWORK_GATEWAYS), data, expect_errors=True) self.assertEqual(res.status_int, error_code) def test_network_gateway_create_invalid_device_spec(self): data = {self._gw_resource: {'name': 'nw-gw', 'tenant_id': _uuid(), 'devices': [{'id': _uuid(), 'invalid': 'xxx'}]}} self._test_network_gateway_create_with_error(data) def test_network_gateway_create_extra_attr_in_device_spec(self): data = {self._gw_resource: {'name': 'nw-gw', 'tenant_id': _uuid(), 'devices': [{'id': _uuid(), 'interface_name': 'xxx', 'extra_attr': 'onetoomany'}]}} self._test_network_gateway_create_with_error(data) def test_network_gateway_update(self): nw_gw_name = 'updated' data = {self._gw_resource: {'name': nw_gw_name}} nw_gw_id = _uuid() return_value = {'id': nw_gw_id, 'name': nw_gw_name} instance = self.plugin.return_value instance.update_network_gateway.return_value = return_value res = self.api.put_json( _get_path('%s/%s' % (networkgw.NETWORK_GATEWAYS, nw_gw_id)), data) instance.update_network_gateway.assert_called_with( mock.ANY, nw_gw_id, network_gateway=data) self.assertEqual(res.status_int, exc.HTTPOk.code) self.assertIn(self._gw_resource, res.json) nw_gw = res.json[self._gw_resource] self.assertEqual(nw_gw['id'], nw_gw_id) self.assertEqual(nw_gw['name'], nw_gw_name) def test_network_gateway_delete(self): nw_gw_id = _uuid() instance = self.plugin.return_value res = self.api.delete(_get_path('%s/%s' % (networkgw.NETWORK_GATEWAYS, nw_gw_id))) instance.delete_network_gateway.assert_called_with(mock.ANY, nw_gw_id) self.assertEqual(res.status_int, exc.HTTPNoContent.code) def test_network_gateway_get(self): nw_gw_id = _uuid() return_value = {self._gw_resource: {'name': 'test', 'devices': [{'id': _uuid(), 'interface_name': 'xxx'}], 'id': nw_gw_id}} instance = self.plugin.return_value instance.get_network_gateway.return_value = return_value res = self.api.get(_get_path('%s/%s' % (networkgw.NETWORK_GATEWAYS, nw_gw_id))) instance.get_network_gateway.assert_called_with(mock.ANY, nw_gw_id, fields=mock.ANY) self.assertEqual(res.status_int, exc.HTTPOk.code) def test_network_gateway_list(self): nw_gw_id = _uuid() return_value = [{self._gw_resource: {'name': 'test', 'devices': [{'id': _uuid(), 'interface_name': 'xxx'}], 'id': nw_gw_id}}] instance = self.plugin.return_value instance.get_network_gateways.return_value = return_value res = self.api.get(_get_path(networkgw.NETWORK_GATEWAYS)) instance.get_network_gateways.assert_called_with(mock.ANY, fields=mock.ANY, filters=mock.ANY) self.assertEqual(res.status_int, exc.HTTPOk.code) def test_network_gateway_connect(self): nw_gw_id = _uuid() nw_id = _uuid() gw_port_id = _uuid() mapping_data = {'network_id': nw_id, 'segmentation_type': 'vlan', 'segmentation_id': '999'} return_value = {'connection_info': { 'network_gateway_id': nw_gw_id, 'port_id': gw_port_id, 'network_id': nw_id}} instance = self.plugin.return_value instance.connect_network.return_value = return_value res = self.api.put_json(_get_path('%s/%s/connect_network' % (networkgw.NETWORK_GATEWAYS, nw_gw_id)), mapping_data) instance.connect_network.assert_called_with(mock.ANY, nw_gw_id, mapping_data) self.assertEqual(res.status_int, exc.HTTPOk.code) nw_conn_res = res.json['connection_info'] self.assertEqual(nw_conn_res['port_id'], gw_port_id) self.assertEqual(nw_conn_res['network_id'], nw_id) def test_network_gateway_disconnect(self): nw_gw_id = _uuid() nw_id = _uuid() mapping_data = {'network_id': nw_id} instance = self.plugin.return_value res = self.api.put_json(_get_path('%s/%s/disconnect_network' % (networkgw.NETWORK_GATEWAYS, nw_gw_id)), mapping_data) instance.disconnect_network.assert_called_with(mock.ANY, nw_gw_id, mapping_data) self.assertEqual(res.status_int, exc.HTTPOk.code) def test_gateway_device_get(self): gw_dev_id = _uuid() return_value = {self._dev_resource: {'name': 'test', 'connector_type': 'stt', 'connector_ip': '1.1.1.1', 'id': gw_dev_id}} instance = self.plugin.return_value instance.get_gateway_device.return_value = return_value res = self.api.get(_get_path('%s/%s' % (networkgw.GATEWAY_DEVICES, gw_dev_id))) instance.get_gateway_device.assert_called_with(mock.ANY, gw_dev_id, fields=mock.ANY) self.assertEqual(res.status_int, exc.HTTPOk.code) def test_gateway_device_list(self): gw_dev_id = _uuid() return_value = [{self._dev_resource: {'name': 'test', 'connector_type': 'stt', 'connector_ip': '1.1.1.1', 'id': gw_dev_id}}] instance = self.plugin.return_value instance.get_gateway_devices.return_value = return_value res = self.api.get(_get_path(networkgw.GATEWAY_DEVICES)) instance.get_gateway_devices.assert_called_with(mock.ANY, fields=mock.ANY, filters=mock.ANY) self.assertEqual(res.status_int, exc.HTTPOk.code) def test_gateway_device_create(self): gw_dev_id = _uuid() tenant_id = _uuid() data = {self._dev_resource: {'name': 'test-dev', 'tenant_id': tenant_id, 'project_id': tenant_id, 'client_certificate': 'xyz', 'connector_type': 'stt', 'connector_ip': '1.1.1.1'}} return_value = data[self._dev_resource].copy() return_value.update({'id': gw_dev_id}) instance = self.plugin.return_value instance.create_gateway_device.return_value = return_value res = self.api.post_json(_get_path(networkgw.GATEWAY_DEVICES), data) instance.create_gateway_device.assert_called_with( mock.ANY, gateway_device=data) self.assertEqual(res.status_int, exc.HTTPCreated.code) self.assertIn(self._dev_resource, res.json) gw_dev = res.json[self._dev_resource] self.assertEqual(gw_dev['id'], gw_dev_id) def _test_gateway_device_create_with_error( self, data, error_code=exc.HTTPBadRequest.code): res = self.api.post_json(_get_path(networkgw.GATEWAY_DEVICES), data, expect_errors=True) self.assertEqual(res.status_int, error_code) def test_gateway_device_create_invalid_connector_type(self): data = {self._gw_resource: {'name': 'test-dev', 'client_certificate': 'xyz', 'tenant_id': _uuid(), 'connector_type': 'invalid', 'connector_ip': '1.1.1.1'}} self._test_gateway_device_create_with_error(data) def test_gateway_device_create_invalid_connector_ip(self): data = {self._gw_resource: {'name': 'test-dev', 'client_certificate': 'xyz', 'tenant_id': _uuid(), 'connector_type': 'stt', 'connector_ip': 'invalid'}} self._test_gateway_device_create_with_error(data) def test_gateway_device_create_extra_attr_in_device_spec(self): data = {self._gw_resource: {'name': 'test-dev', 'client_certificate': 'xyz', 'tenant_id': _uuid(), 'alien_attribute': 'E.T.', 'connector_type': 'stt', 'connector_ip': '1.1.1.1'}} self._test_gateway_device_create_with_error(data) def test_gateway_device_update(self): gw_dev_name = 'updated' data = {self._dev_resource: {'name': gw_dev_name}} gw_dev_id = _uuid() return_value = {'id': gw_dev_id, 'name': gw_dev_name} instance = self.plugin.return_value instance.update_gateway_device.return_value = return_value res = self.api.put_json( _get_path('%s/%s' % (networkgw.GATEWAY_DEVICES, gw_dev_id)), data) instance.update_gateway_device.assert_called_with( mock.ANY, gw_dev_id, gateway_device=data) self.assertEqual(res.status_int, exc.HTTPOk.code) self.assertIn(self._dev_resource, res.json) gw_dev = res.json[self._dev_resource] self.assertEqual(gw_dev['id'], gw_dev_id) self.assertEqual(gw_dev['name'], gw_dev_name) def test_gateway_device_delete(self): gw_dev_id = _uuid() instance = self.plugin.return_value res = self.api.delete(_get_path('%s/%s' % (networkgw.GATEWAY_DEVICES, gw_dev_id))) instance.delete_gateway_device.assert_called_with(mock.ANY, gw_dev_id) self.assertEqual(res.status_int, exc.HTTPNoContent.code) class NetworkGatewayDbTestCase(test_db_plugin.NeutronDbPluginV2TestCase): """Unit tests for Network Gateway DB support.""" def setUp(self, plugin=None, ext_mgr=None): if not plugin: plugin = '%s.%s' % (__name__, TestNetworkGatewayPlugin.__name__) if not ext_mgr: ext_mgr = TestExtensionManager() self.gw_resource = networkgw.GATEWAY_RESOURCE_NAME self.dev_resource = networkgw.DEVICE_RESOURCE_NAME super(NetworkGatewayDbTestCase, self).setUp(plugin=plugin, ext_mgr=ext_mgr) def _create_network_gateway(self, fmt, tenant_id, name=None, devices=None, arg_list=None, **kwargs): data = {self.gw_resource: {'tenant_id': tenant_id, 'devices': devices}} if name: data[self.gw_resource]['name'] = name for arg in arg_list or (): # Arg must be present and not empty if arg in kwargs and kwargs[arg]: data[self.gw_resource][arg] = kwargs[arg] nw_gw_req = self.new_create_request(networkgw.NETWORK_GATEWAYS, data, fmt) if (kwargs.get('set_context') and tenant_id): # create a specific auth context for this request nw_gw_req.environ['neutron.context'] = context.Context( '', tenant_id) return nw_gw_req.get_response(self.ext_api) @contextlib.contextmanager def _network_gateway(self, name='gw1', devices=None, fmt='json', tenant_id=_uuid()): device = None if not devices: device_res = self._create_gateway_device( fmt, tenant_id, 'stt', '1.1.1.1', 'xxxxxx', name='whatever') if device_res.status_int >= 400: raise exc.HTTPClientError(code=device_res.status_int) device = self.deserialize(fmt, device_res) devices = [{'id': device[self.dev_resource]['id'], 'interface_name': 'xyz'}] res = self._create_network_gateway(fmt, tenant_id, name=name, devices=devices) if res.status_int >= 400: raise exc.HTTPClientError(code=res.status_int) network_gateway = self.deserialize(fmt, res) yield network_gateway self._delete(networkgw.NETWORK_GATEWAYS, network_gateway[self.gw_resource]['id']) if device: self._delete(networkgw.GATEWAY_DEVICES, device[self.dev_resource]['id']) def _create_gateway_device(self, fmt, tenant_id, connector_type, connector_ip, client_certificate, name=None, set_context=False): data = {self.dev_resource: {'tenant_id': tenant_id, 'connector_type': connector_type, 'connector_ip': connector_ip, 'client_certificate': client_certificate}} if name: data[self.dev_resource]['name'] = name gw_dev_req = self.new_create_request(networkgw.GATEWAY_DEVICES, data, fmt) if (set_context and tenant_id): # create a specific auth context for this request gw_dev_req.environ['neutron.context'] = context.Context( '', tenant_id) return gw_dev_req.get_response(self.ext_api) def _update_gateway_device(self, fmt, gateway_device_id, connector_type=None, connector_ip=None, client_certificate=None, name=None, set_context=False, tenant_id=None): data = {self.dev_resource: {}} if connector_type: data[self.dev_resource]['connector_type'] = connector_type if connector_ip: data[self.dev_resource]['connector_ip'] = connector_ip if client_certificate: data[self.dev_resource]['client_certificate'] = client_certificate if name: data[self.dev_resource]['name'] = name gw_dev_req = self.new_update_request(networkgw.GATEWAY_DEVICES, data, gateway_device_id, fmt) if (set_context and tenant_id): # create a specific auth context for this request gw_dev_req.environ['neutron.context'] = context.Context( '', tenant_id) return gw_dev_req.get_response(self.ext_api) @contextlib.contextmanager def _gateway_device(self, name='gw_dev', connector_type='stt', connector_ip='1.1.1.1', client_certificate='xxxxxxxxxxxxxxx', fmt='json', tenant_id=_uuid()): res = self._create_gateway_device( fmt, tenant_id, connector_type=connector_type, connector_ip=connector_ip, client_certificate=client_certificate, name=name) if res.status_int >= 400: raise exc.HTTPClientError(code=res.status_int) gateway_device = self.deserialize(fmt, res) yield gateway_device self._delete(networkgw.GATEWAY_DEVICES, gateway_device[self.dev_resource]['id']) def _gateway_action(self, action, network_gateway_id, network_id, segmentation_type, segmentation_id=None, expected_status=exc.HTTPOk.code): connection_data = {'network_id': network_id, 'segmentation_type': segmentation_type} if segmentation_id: connection_data['segmentation_id'] = segmentation_id req = self.new_action_request(networkgw.NETWORK_GATEWAYS, connection_data, network_gateway_id, "%s_network" % action) res = req.get_response(self.ext_api) self.assertEqual(res.status_int, expected_status) return self.deserialize('json', res) def _test_connect_and_disconnect_network(self, segmentation_type, segmentation_id=None): with self._network_gateway() as gw: with self.network() as net: body = self._gateway_action('connect', gw[self.gw_resource]['id'], net['network']['id'], segmentation_type, segmentation_id) self.assertIn('connection_info', body) connection_info = body['connection_info'] for attr in ('network_id', 'port_id', 'network_gateway_id'): self.assertIn(attr, connection_info) # fetch port and confirm device_id gw_port_id = connection_info['port_id'] port_body = self._show('ports', gw_port_id) self.assertEqual(port_body['port']['device_id'], gw[self.gw_resource]['id']) # Clean up - otherwise delete will fail body = self._gateway_action('disconnect', gw[self.gw_resource]['id'], net['network']['id'], segmentation_type, segmentation_id) # Check associated port has been deleted too body = self._show('ports', gw_port_id, expected_code=exc.HTTPNotFound.code) def test_create_network_gateway(self): tenant_id = _uuid() _gateway_device = (lambda name: self._gateway_device(name=name, tenant_id=tenant_id)) with _gateway_device('dev_1') as dev_1: with _gateway_device('dev_2') as dev_2: name = 'test-gw' dev_1_id = dev_1[self.dev_resource]['id'] dev_2_id = dev_2[self.dev_resource]['id'] devices = [{'id': dev_1_id, 'interface_name': 'xxx'}, {'id': dev_2_id, 'interface_name': 'yyy'}] keys = [('devices', devices), ('name', name)] with self._network_gateway(name=name, devices=devices, tenant_id=tenant_id) as gw: for k, v in keys: self.assertEqual(gw[self.gw_resource][k], v) def test_create_network_gateway_no_interface_name(self): tenant_id = _uuid() with self._gateway_device(tenant_id=tenant_id) as dev: name = 'test-gw' devices = [{'id': dev[self.dev_resource]['id']}] exp_devices = devices exp_devices[0]['interface_name'] = 'breth0' keys = [('devices', exp_devices), ('name', name)] with self._network_gateway(name=name, devices=devices, tenant_id=tenant_id) as gw: for k, v in keys: self.assertEqual(gw[self.gw_resource][k], v) def test_create_network_gateway_not_owned_device_raises_404(self): # Create a device with a different tenant identifier with self._gateway_device(name='dev', tenant_id=_uuid()) as dev: name = 'test-gw' dev_id = dev[self.dev_resource]['id'] devices = [{'id': dev_id, 'interface_name': 'xxx'}] res = self._create_network_gateway( 'json', _uuid(), name=name, devices=devices) self.assertEqual(404, res.status_int) def test_create_network_gateway_non_existent_device_raises_404(self): name = 'test-gw' devices = [{'id': _uuid(), 'interface_name': 'xxx'}] res = self._create_network_gateway( 'json', _uuid(), name=name, devices=devices) self.assertEqual(404, res.status_int) def test_delete_network_gateway(self): tenant_id = _uuid() with self._gateway_device(tenant_id=tenant_id) as dev: name = 'test-gw' device_id = dev[self.dev_resource]['id'] devices = [{'id': device_id, 'interface_name': 'xxx'}] with self._network_gateway(name=name, devices=devices, tenant_id=tenant_id) as gw: # Nothing to do here - just let the gateway go gw_id = gw[self.gw_resource]['id'] # Verify nothing left on db session = db_api.get_reader_session() dev_query = session.query( nsx_models.NetworkGatewayDevice).filter( nsx_models.NetworkGatewayDevice.id == device_id) self.assertIsNone(dev_query.first()) gw_query = session.query(nsx_models.NetworkGateway).filter( nsx_models.NetworkGateway.id == gw_id) self.assertIsNone(gw_query.first()) def test_update_network_gateway(self): with self._network_gateway() as gw: data = {self.gw_resource: {'name': 'new_name'}} req = self.new_update_request(networkgw.NETWORK_GATEWAYS, data, gw[self.gw_resource]['id']) res = self.deserialize('json', req.get_response(self.ext_api)) self.assertEqual(res[self.gw_resource]['name'], data[self.gw_resource]['name']) def test_get_network_gateway(self): with self._network_gateway(name='test-gw') as gw: req = self.new_show_request(networkgw.NETWORK_GATEWAYS, gw[self.gw_resource]['id']) res = self.deserialize('json', req.get_response(self.ext_api)) self.assertEqual(res[self.gw_resource]['name'], gw[self.gw_resource]['name']) def test_list_network_gateways(self): with self._network_gateway(name='test-gw-1') as gw1: with self._network_gateway(name='test_gw_2') as gw2: req = self.new_list_request(networkgw.NETWORK_GATEWAYS) res = self.deserialize('json', req.get_response(self.ext_api)) key = self.gw_resource + 's' self.assertEqual(len(res[key]), 2) self.assertEqual(res[key][0]['name'], gw1[self.gw_resource]['name']) self.assertEqual(res[key][1]['name'], gw2[self.gw_resource]['name']) def _test_list_network_gateway_with_multiple_connections( self, expected_gateways=1): with self._network_gateway() as gw: with self.network() as net_1: self._gateway_action('connect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 555) self._gateway_action('connect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 777) req = self.new_list_request(networkgw.NETWORK_GATEWAYS) res = self.deserialize('json', req.get_response(self.ext_api)) key = self.gw_resource + 's' self.assertEqual(len(res[key]), expected_gateways) for item in res[key]: self.assertIn('ports', item) if item['id'] == gw[self.gw_resource]['id']: gw_ports = item['ports'] self.assertEqual(len(gw_ports), 2) segmentation_ids = [555, 777] for gw_port in gw_ports: self.assertEqual('vlan', gw_port['segmentation_type']) self.assertIn(gw_port['segmentation_id'], segmentation_ids) segmentation_ids.remove(gw_port['segmentation_id']) # Required cleanup self._gateway_action('disconnect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 555) self._gateway_action('disconnect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 777) def test_list_network_gateway_with_multiple_connections(self): self._test_list_network_gateway_with_multiple_connections() def test_connect_and_disconnect_network(self): self._test_connect_and_disconnect_network('flat') def test_connect_and_disconnect_network_no_seg_type(self): self._test_connect_and_disconnect_network(None) def test_connect_and_disconnect_network_vlan_with_segmentation_id(self): self._test_connect_and_disconnect_network('vlan', 999) def test_connect_and_disconnect_network_vlan_without_segmentation_id(self): self._test_connect_and_disconnect_network('vlan') def test_connect_network_multiple_times(self): with self._network_gateway() as gw: with self.network() as net_1: self._gateway_action('connect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 555) self._gateway_action('connect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 777) self._gateway_action('disconnect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 555) self._gateway_action('disconnect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 777) def test_connect_network_multiple_gateways(self): with self._network_gateway() as gw_1: with self._network_gateway() as gw_2: with self.network() as net_1: self._gateway_action('connect', gw_1[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 555) self._gateway_action('connect', gw_2[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 555) self._gateway_action('disconnect', gw_1[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 555) self._gateway_action('disconnect', gw_2[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 555) def test_connect_network_mapping_in_use_returns_409(self): with self._network_gateway() as gw: with self.network() as net_1: self._gateway_action('connect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 555) with self.network() as net_2: self._gateway_action('connect', gw[self.gw_resource]['id'], net_2['network']['id'], 'vlan', 555, expected_status=exc.HTTPConflict.code) # Clean up - otherwise delete will fail self._gateway_action('disconnect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 555) def test_connect_network_vlan_invalid_seg_id_returns_400(self): with self._network_gateway() as gw: with self.network() as net: # above upper bound self._gateway_action('connect', gw[self.gw_resource]['id'], net['network']['id'], 'vlan', 4095, expected_status=exc.HTTPBadRequest.code) # below lower bound (0 is valid for NSX plugin) self._gateway_action('connect', gw[self.gw_resource]['id'], net['network']['id'], 'vlan', -1, expected_status=exc.HTTPBadRequest.code) def test_connect_invalid_network_returns_400(self): with self._network_gateway() as gw: self._gateway_action('connect', gw[self.gw_resource]['id'], 'hohoho', 'vlan', 555, expected_status=exc.HTTPBadRequest.code) def test_connect_unspecified_network_returns_400(self): with self._network_gateway() as gw: self._gateway_action('connect', gw[self.gw_resource]['id'], None, 'vlan', 555, expected_status=exc.HTTPBadRequest.code) def test_disconnect_network_ambiguous_returns_409(self): with self._network_gateway() as gw: with self.network() as net_1: self._gateway_action('connect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 555) self._gateway_action('connect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 777) # This should raise self._gateway_action('disconnect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', expected_status=exc.HTTPConflict.code) self._gateway_action('disconnect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 555) self._gateway_action('disconnect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 777) def test_delete_active_gateway_port_returns_409(self): with self._network_gateway() as gw: with self.network() as net_1: body = self._gateway_action('connect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 555) # fetch port id and try to delete it gw_port_id = body['connection_info']['port_id'] self._delete('ports', gw_port_id, expected_code=exc.HTTPConflict.code) body = self._gateway_action('disconnect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 555) def test_delete_network_gateway_active_connections_returns_409(self): with self._network_gateway() as gw: with self.network() as net_1: self._gateway_action('connect', gw[self.gw_resource]['id'], net_1['network']['id'], 'flat') self._delete(networkgw.NETWORK_GATEWAYS, gw[self.gw_resource]['id'], expected_code=exc.HTTPConflict.code) self._gateway_action('disconnect', gw[self.gw_resource]['id'], net_1['network']['id'], 'flat') def test_disconnect_non_existing_connection_returns_404(self): with self._network_gateway() as gw: with self.network() as net_1: self._gateway_action('connect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 555) self._gateway_action('disconnect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 999, expected_status=exc.HTTPNotFound.code) self._gateway_action('disconnect', gw[self.gw_resource]['id'], net_1['network']['id'], 'vlan', 555) def test_create_gateway_device( self, expected_status=networkgw_db.STATUS_UNKNOWN): with self._gateway_device(name='test-dev', connector_type='stt', connector_ip='1.1.1.1', client_certificate='xyz') as dev: self.assertEqual(dev[self.dev_resource]['name'], 'test-dev') self.assertEqual(dev[self.dev_resource]['connector_type'], 'stt') self.assertEqual(dev[self.dev_resource]['connector_ip'], '1.1.1.1') self.assertEqual(dev[self.dev_resource]['status'], expected_status) def test_list_gateway_devices(self): gateway_device = (lambda name, connector_ip, client_cert: self._gateway_device(name=name, connector_type='stt', connector_ip=connector_ip, client_certificate=client_cert)) with gateway_device('test-dev-1', '1.1.1.1', 'xyz') as dev_1,\ gateway_device('test-dev-2', '2.2.2.2', 'qwe') as dev_2: req = self.new_list_request(networkgw.GATEWAY_DEVICES) res = self.deserialize('json', req.get_response(self.ext_api)) devices = res[networkgw.GATEWAY_DEVICES.replace('-', '_')] self.assertEqual(len(devices), 2) dev_1 = devices[0] dev_2 = devices[1] self.assertEqual(dev_1['name'], 'test-dev-1') self.assertEqual(dev_2['name'], 'test-dev-2') def test_get_gateway_device( self, expected_status=networkgw_db.STATUS_UNKNOWN): with self._gateway_device(name='test-dev', connector_type='stt', connector_ip='1.1.1.1', client_certificate='xyz') as dev: req = self.new_show_request(networkgw.GATEWAY_DEVICES, dev[self.dev_resource]['id']) res = self.deserialize('json', req.get_response(self.ext_api)) self.assertEqual(res[self.dev_resource]['name'], 'test-dev') self.assertEqual(res[self.dev_resource]['connector_type'], 'stt') self.assertEqual(res[self.dev_resource]['connector_ip'], '1.1.1.1') self.assertEqual(res[self.dev_resource]['status'], expected_status) def test_update_gateway_device( self, expected_status=networkgw_db.STATUS_UNKNOWN): with self._gateway_device(name='test-dev', connector_type='stt', connector_ip='1.1.1.1', client_certificate='xyz') as dev: self._update_gateway_device('json', dev[self.dev_resource]['id'], connector_type='stt', connector_ip='2.2.2.2', name='test-dev-upd') req = self.new_show_request(networkgw.GATEWAY_DEVICES, dev[self.dev_resource]['id']) res = self.deserialize('json', req.get_response(self.ext_api)) self.assertEqual(res[self.dev_resource]['name'], 'test-dev-upd') self.assertEqual(res[self.dev_resource]['connector_type'], 'stt') self.assertEqual(res[self.dev_resource]['connector_ip'], '2.2.2.2') self.assertEqual(res[self.dev_resource]['status'], expected_status) def test_delete_gateway_device(self): with self._gateway_device(name='test-dev', connector_type='stt', connector_ip='1.1.1.1', client_certificate='xyz') as dev: # Nothing to do here - just note the device id dev_id = dev[self.dev_resource]['id'] # Verify nothing left on db session = db_api.get_reader_session() dev_query = session.query(nsx_models.NetworkGatewayDevice) dev_query.filter(nsx_models.NetworkGatewayDevice.id == dev_id) self.assertIsNone(dev_query.first()) class TestNetworkGateway(test_nsx_plugin.NsxPluginV2TestCase, NetworkGatewayDbTestCase): def setUp(self, plugin=vmware.PLUGIN_NAME, ext_mgr=None): cfg.CONF.set_override('api_extensions_path', vmware.NSXEXT_PATH) # Mock l2gwlib calls for gateway devices since this resource is not # mocked through the fake NSX API client create_gw_dev_patcher = mock.patch.object( l2gwlib, 'create_gateway_device') update_gw_dev_patcher = mock.patch.object( l2gwlib, 'update_gateway_device') delete_gw_dev_patcher = mock.patch.object( l2gwlib, 'delete_gateway_device') get_gw_dev_status_patcher = mock.patch.object( l2gwlib, 'get_gateway_device_status') get_gw_dev_statuses_patcher = mock.patch.object( l2gwlib, 'get_gateway_devices_status') self.mock_create_gw_dev = create_gw_dev_patcher.start() self.mock_create_gw_dev.return_value = {'uuid': 'callejon'} self.mock_update_gw_dev = update_gw_dev_patcher.start() delete_gw_dev_patcher.start() self.mock_get_gw_dev_status = get_gw_dev_status_patcher.start() get_gw_dev_statuses = get_gw_dev_statuses_patcher.start() get_gw_dev_statuses.return_value = {} super(TestNetworkGateway, self).setUp(plugin=plugin, ext_mgr=ext_mgr) def test_create_network_gateway_name_exceeds_40_chars(self): name = 'this_is_a_gateway_whose_name_is_longer_than_40_chars' with self._network_gateway(name=name) as nw_gw: # Assert Neutron name is not truncated self.assertEqual(nw_gw[self.gw_resource]['name'], name) def test_update_network_gateway_with_name_calls_backend(self): with mock.patch.object( nsxlib.l2gateway, 'update_l2_gw_service') as mock_update_gw: with self._network_gateway(name='cavani') as nw_gw: nw_gw_id = nw_gw[self.gw_resource]['id'] self._update(networkgw.NETWORK_GATEWAYS, nw_gw_id, {self.gw_resource: {'name': 'higuain'}}) mock_update_gw.assert_called_once_with( mock.ANY, nw_gw_id, 'higuain') def test_update_network_gateway_without_name_does_not_call_backend(self): with mock.patch.object( nsxlib.l2gateway, 'update_l2_gw_service') as mock_update_gw: with self._network_gateway(name='something') as nw_gw: nw_gw_id = nw_gw[self.gw_resource]['id'] self._update(networkgw.NETWORK_GATEWAYS, nw_gw_id, {self.gw_resource: {}}) self.assertEqual(mock_update_gw.call_count, 0) def test_update_network_gateway_name_exceeds_40_chars(self): new_name = 'this_is_a_gateway_whose_name_is_longer_than_40_chars' with self._network_gateway(name='something') as nw_gw: nw_gw_id = nw_gw[self.gw_resource]['id'] self._update(networkgw.NETWORK_GATEWAYS, nw_gw_id, {self.gw_resource: {'name': new_name}}) req = self.new_show_request(networkgw.NETWORK_GATEWAYS, nw_gw_id) res = self.deserialize('json', req.get_response(self.ext_api)) # Assert Neutron name is not truncated self.assertEqual(new_name, res[self.gw_resource]['name']) # Assert NSX name is truncated self.assertEqual( new_name[:40], self.fc._fake_gatewayservice_dict[nw_gw_id]['display_name']) def test_create_network_gateway_nsx_error_returns_500(self): def raise_nsx_api_exc(*args, **kwargs): raise api_exc.NsxApiException() with mock.patch.object(nsxlib.l2gateway, 'create_l2_gw_service', new=raise_nsx_api_exc): tenant_id = _uuid() with self._gateway_device(tenant_id=tenant_id) as dev: res = self._create_network_gateway( self.fmt, tenant_id, name='yyy', devices=[{'id': dev[self.dev_resource]['id']}]) self.assertEqual(500, res.status_int) def test_create_network_gateway_nsx_error_returns_409(self): with mock.patch.object(nsxlib.l2gateway, 'create_l2_gw_service', side_effect=api_exc.Conflict): tenant_id = _uuid() with self._gateway_device(tenant_id=tenant_id) as dev: res = self._create_network_gateway( self.fmt, tenant_id, name='yyy', devices=[{'id': dev[self.dev_resource]['id']}]) self.assertEqual(409, res.status_int) def test_list_network_gateways(self): with self._network_gateway(name='test-gw-1') as gw1: with self._network_gateway(name='test_gw_2') as gw2: req = self.new_list_request(networkgw.NETWORK_GATEWAYS) res = self.deserialize('json', req.get_response(self.ext_api)) # Ensure we always get the list in the same order gateways = sorted( res[self.gw_resource + 's'], key=lambda k: k['name']) self.assertEqual(len(gateways), 3) # We expect the default gateway too self.assertEqual(gateways[0]['default'], True) self.assertEqual(gateways[1]['name'], gw1[self.gw_resource]['name']) self.assertEqual(gateways[2]['name'], gw2[self.gw_resource]['name']) def test_list_network_gateway_with_multiple_connections(self): self._test_list_network_gateway_with_multiple_connections( expected_gateways=2) def test_show_network_gateway_nsx_error_returns_404(self): invalid_id = 'b5afd4a9-eb71-4af7-a082-8fc625a35b61' req = self.new_show_request(networkgw.NETWORK_GATEWAYS, invalid_id) res = req.get_response(self.ext_api) self.assertEqual(exc.HTTPNotFound.code, res.status_int) def test_create_gateway_device(self): self.mock_get_gw_dev_status.return_value = True super(TestNetworkGateway, self).test_create_gateway_device( expected_status=networkgw_db.STATUS_ACTIVE) def test_create_gateway_device_status_down(self): self.mock_get_gw_dev_status.return_value = False super(TestNetworkGateway, self).test_create_gateway_device( expected_status=networkgw_db.STATUS_DOWN) def test_create_gateway_device_invalid_cert_returns_400(self): self.mock_create_gw_dev.side_effect = ( nsx_exc.InvalidSecurityCertificate) res = self._create_gateway_device( 'json', _uuid(), connector_type='stt', connector_ip='1.1.1.1', client_certificate='invalid_certificate', name='whatever') self.assertEqual(res.status_int, 400) def test_get_gateway_device(self): self.mock_get_gw_dev_status.return_value = True super(TestNetworkGateway, self).test_get_gateway_device( expected_status=networkgw_db.STATUS_ACTIVE) def test_get_gateway_device_status_down(self): self.mock_get_gw_dev_status.return_value = False super(TestNetworkGateway, self).test_get_gateway_device( expected_status=networkgw_db.STATUS_DOWN) def test_update_gateway_device(self): self.mock_get_gw_dev_status.return_value = True super(TestNetworkGateway, self).test_update_gateway_device( expected_status=networkgw_db.STATUS_ACTIVE) def test_update_gateway_device_status_down(self): self.mock_get_gw_dev_status.return_value = False super(TestNetworkGateway, self).test_update_gateway_device( expected_status=networkgw_db.STATUS_DOWN) def test_update_gateway_device_invalid_cert_returns_400(self): with self._gateway_device( name='whaterver', connector_type='stt', connector_ip='1.1.1.1', client_certificate='iminvalidbutiitdoesnotmatter') as dev: self.mock_update_gw_dev.side_effect = ( nsx_exc.InvalidSecurityCertificate) res = self._update_gateway_device( 'json', dev[self.dev_resource]['id'], client_certificate='invalid_certificate') self.assertEqual(res.status_int, 400) class TestNetworkGatewayPlugin(db_base_plugin_v2.NeutronDbPluginV2, networkgw_db.NetworkGatewayMixin): """Simple plugin class for testing db support for network gateway ext.""" supported_extension_aliases = ["network-gateway"] def __init__(self, **args): super(TestNetworkGatewayPlugin, self).__init__(**args) extensions.append_api_extensions_path([vmware.NSXEXT_PATH]) def delete_port(self, context, id, nw_gw_port_check=True): if nw_gw_port_check: port = self._get_port(context, id) self.prevent_network_gateway_port_deletion(context, port) super(TestNetworkGatewayPlugin, self).delete_port(context, id)