openstack
/
neutron-tempest-plugin
Code Issues Proposed changes

Add base API tests for port forwarding 

This patch adds base client support and API tests for port forwarding
feature.

This patch also enable port_forwarding service plugin in
neutron_tempest_plugin CI jobs.

Depends-On: https://review.opendev.org/#/c/661581/

Change-Id: Ice58232b640ea8aa28d7a54aa9cf14e6ad0a2bb0
This commit is contained in:
Slawek Kaplonski 2019-05-26 22:38:35 +02:00
parent 8dd49aac9f
commit 003fcae7f9
4 changed files with 293 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
.zuul.yaml
View File

@ -26,6 +26,7 @@
- dns-domain-ports
- dns-integration
- empty-string-filtering
- expose-port-forwarding-in-fip
- ext-gw-mode
- external-net
- extra_dhcp_opt
@ -33,6 +34,7 @@
- filter-validation
- fip-port-details
- flavors
- floating-ip-port-forwarding
- floatingip-pools
- ip-substring-filtering
- l3-flavors
@ -94,6 +96,7 @@
neutron-trunk: true
neutron-uplink-status-propagation: true
neutron-network-segment-range: true
neutron-port-forwarding: true
devstack_local_conf:
post-config:
$NEUTRON_CONF:
@ -249,6 +252,7 @@
- dns-domain-ports
- dns-integration
- empty-string-filtering
- expose-port-forwarding-in-fip
- ext-gw-mode
- external-net
- extra_dhcp_opt
@ -257,6 +261,7 @@
- fip-port-details
- flavors
- floatingip-pools
- floating-ip-port-forwarding
- ip-substring-filtering
- l3-flavors
- l3-ha
@ -325,12 +330,14 @@
- dns-domain-ports
- dns-integration
- empty-string-filtering
- expose-port-forwarding-in-fip
- ext-gw-mode
- external-net
- extra_dhcp_opt
- extraroute
- fip-port-details
- flavors
- floating-ip-port-forwarding
- ip-substring-filtering
- l3-flavors
- l3-ha

65
neutron_tempest_plugin/api/base.py
View File

@ -117,6 +117,7 @@ class BaseNetworkTest(test.BaseTestCase):
cls.ports = []
cls.routers = []
cls.floating_ips = []
cls.port_forwardings = []
cls.metering_labels = []
cls.service_profiles = []
cls.flavors = []
@ -144,6 +145,10 @@ class BaseNetworkTest(test.BaseTestCase):
for trunk in cls.trunks:
cls._try_delete_resource(cls.delete_trunk, trunk)
# Clean up port forwardings
for pf in cls.port_forwardings:
cls._try_delete_resource(cls.delete_port_forwarding, pf)
# Clean up floating IPs
for floating_ip in cls.floating_ips:
cls._try_delete_resource(cls.delete_floatingip, floating_ip)
@ -651,6 +656,66 @@ class BaseNetworkTest(test.BaseTestCase):
client = client or floating_ip.get('client') or cls.client
client.delete_floatingip(floating_ip['id'])
@classmethod
def create_port_forwarding(cls, fip_id, internal_port_id,
internal_port, external_port,
internal_ip_address=None, protocol="tcp",
client=None):
"""Creates a port forwarding.
Create a port forwarding and schedule it for later deletion.
If a client is passed, then it is used for deleting the PF too.
:param fip_id: The ID of the floating IP address.
:param internal_port_id: The ID of the Neutron port associated to
the floating IP port forwarding.
:param internal_port: The TCP/UDP/other protocol port number of the
Neutron port fixed IP address associated to the floating ip
port forwarding.
:param external_port: The TCP/UDP/other protocol port number of
the port forwarding floating IP address.
:param internal_ip_address: The fixed IPv4 address of the Neutron
port associated to the floating IP port forwarding.
:param protocol: The IP protocol used in the floating IP port
forwarding.
:param client: network client to be used for creating and cleaning up
the floating IP port forwarding.
"""
client = client or cls.client
pf = client.create_port_forwarding(
fip_id, internal_port_id, internal_port, external_port,
internal_ip_address, protocol)['port_forwarding']
# save ID of floating IP associated with port forwarding for final
# cleanup
pf['floatingip_id'] = fip_id
# save client to be used later in cls.delete_port_forwarding
# for final cleanup
pf['client'] = client
cls.port_forwardings.append(pf)
return pf
@classmethod
def delete_port_forwarding(cls, pf, client=None):
"""Delete port forwarding
:param client: Client to be used
If client is not given it will use the client used to create
the port forwarding, or cls.client if unknown.
"""
client = client or pf.get('client') or cls.client
client.delete_port_forwarding(pf['floatingip_id'], pf['id'])
@classmethod
def create_router_interface(cls, router_id, subnet_id):
"""Wrapper utility that returns a router interface."""

172
neutron_tempest_plugin/api/test_port_forwardings.py Normal file
View File

@ -0,0 +1,172 @@
# Copyright 2019 Red Hat, 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.
from tempest.common import utils
from tempest.lib.common.utils import data_utils
from tempest.lib import decorators
from tempest.lib import exceptions
from neutron_tempest_plugin.api import base
from neutron_tempest_plugin import config
CONF = config.CONF
class PortForwardingTestJSON(base.BaseNetworkTest):
required_extensions = ['router', 'floating-ip-port-forwarding']
@classmethod
def resource_setup(cls):
super(PortForwardingTestJSON, cls).resource_setup()
cls.ext_net_id = CONF.network.public_network_id
# Create network, subnet, router and add interface
cls.network = cls.create_network()
cls.subnet = cls.create_subnet(cls.network)
cls.router = cls.create_router(data_utils.rand_name('router'),
external_network_id=cls.ext_net_id)
cls.create_router_interface(cls.router['id'], cls.subnet['id'])
@decorators.idempotent_id('829a446e-46bc-41ce-b442-6e428aeb3c19')
def test_port_forwarding_life_cycle(self):
fip = self.create_floatingip()
port = self.create_port(self.network)
# Create port forwarding for one TCP port
created_pf = self.create_port_forwarding(
fip['id'],
internal_port_id=port['id'],
internal_ip_address=port['fixed_ips'][0]['ip_address'],
internal_port=1111, external_port=2222, protocol="tcp")
self.assertEqual(1111, created_pf['internal_port'])
self.assertEqual(2222, created_pf['external_port'])
self.assertEqual('tcp', created_pf['protocol'])
self.assertEqual(port['fixed_ips'][0]['ip_address'],
created_pf['internal_ip_address'])
# Show created port forwarding
body = self.client.get_port_forwarding(
fip['id'], created_pf['id'])
pf = body['port_forwarding']
self.assertEqual(1111, pf['internal_port'])
self.assertEqual(2222, pf['external_port'])
self.assertEqual('tcp', pf['protocol'])
self.assertEqual(port['fixed_ips'][0]['ip_address'],
pf['internal_ip_address'])
# Update port forwarding
body = self.client.update_port_forwarding(
fip['id'], pf['id'], internal_port=3333)
pf = body['port_forwarding']
self.assertEqual(3333, pf['internal_port'])
self.assertEqual(2222, pf['external_port'])
self.assertEqual('tcp', pf['protocol'])
self.assertEqual(port['fixed_ips'][0]['ip_address'],
pf['internal_ip_address'])
# Delete port forwarding
self.client.delete_port_forwarding(fip['id'], pf['id'])
self.assertRaises(exceptions.NotFound,
self.client.get_port_forwarding,
fip['id'], pf['id'])
@decorators.idempotent_id('aa842070-39ef-4b09-9df9-e723934f96f8')
@utils.requires_ext(extension="expose-port-forwarding-in-fip",
service="network")
def test_port_forwarding_info_in_fip_details(self):
fip = self.create_floatingip()
port = self.create_port(self.network)
# Ensure that FIP don't have information about any port forwarding yet
fip = self.client.show_floatingip(fip['id'])['floatingip']
self.assertEqual(0, len(fip['port_forwardings']))
# Now create port forwarding and ensure that it is visible in FIP's
# details
pf = self.create_port_forwarding(
fip['id'],
internal_port_id=port['id'],
internal_ip_address=port['fixed_ips'][0]['ip_address'],
internal_port=1111, external_port=2222, protocol="tcp")
fip = self.client.show_floatingip(fip['id'])['floatingip']
self.assertEqual(1, len(fip['port_forwardings']))
self.assertEqual(1111, fip['port_forwardings'][0]['internal_port'])
self.assertEqual(2222, fip['port_forwardings'][0]['external_port'])
self.assertEqual('tcp', fip['port_forwardings'][0]['protocol'])
self.assertEqual(port['fixed_ips'][0]['ip_address'],
fip['port_forwardings'][0]['internal_ip_address'])
# Delete port forwarding and ensure that it's not in FIP's details
# anymore
self.client.delete_port_forwarding(fip['id'], pf['id'])
fip = self.client.show_floatingip(fip['id'])['floatingip']
self.assertEqual(0, len(fip['port_forwardings']))
@decorators.idempotent_id('8202cded-7e82-4420-9585-c091105404f6')
def test_associate_2_port_forwardings_to_floating_ip(self):
fip = self.create_floatingip()
forwardings_data = [(1111, 2222), (3333, 4444)]
created_pfs = []
for data in forwardings_data:
internal_port = data[0]
external_port = data[1]
port = self.create_port(self.network)
created_pf = self.create_port_forwarding(
fip['id'],
internal_port_id=port['id'],
internal_ip_address=port['fixed_ips'][0]['ip_address'],
internal_port=internal_port, external_port=external_port,
protocol="tcp")
self.assertEqual(internal_port, created_pf['internal_port'])
self.assertEqual(external_port, created_pf['external_port'])
self.assertEqual('tcp', created_pf['protocol'])
self.assertEqual(port['fixed_ips'][0]['ip_address'],
created_pf['internal_ip_address'])
created_pfs.append(created_pf)
# Check that all PFs are visible in Floating IP details
fip = self.client.show_floatingip(fip['id'])['floatingip']
self.assertEqual(len(forwardings_data), len(fip['port_forwardings']))
for pf in created_pfs:
expected_pf = {
'external_port': pf['external_port'],
'internal_port': pf['internal_port'],
'protocol': pf['protocol'],
'internal_ip_address': pf['internal_ip_address']}
self.assertIn(expected_pf, fip['port_forwardings'])
# Test list of port forwardings
port_forwardings = self.client.list_port_forwardings(
fip['id'])['port_forwardings']
self.assertEqual(len(forwardings_data), len(port_forwardings))
for pf in created_pfs:
expected_pf = pf.copy()
expected_pf.pop('client')
expected_pf.pop('floatingip_id')
self.assertIn(expected_pf, port_forwardings)
@decorators.idempotent_id('6a34e811-66d1-4f63-aa4d-9013f15deb62')
def test_associate_port_forwarding_to_used_floating_ip(self):
port_for_fip = self.create_port(self.network)
fip = self.create_floatingip(port=port_for_fip)
port = self.create_port(self.network)
self.assertRaises(
exceptions.Conflict,
self.create_port_forwarding,
fip['id'],
internal_port_id=port['id'],
internal_ip_address=port['fixed_ips'][0]['ip_address'],
internal_port=1111, external_port=2222,
protocol="tcp")

49
neutron_tempest_plugin/services/network/json/network_client.py
View File

@ -938,6 +938,55 @@ class NetworkClientJSON(service_client.RestClient):
body = jsonutils.loads(resp_body)
return service_client.ResponseBody(put_resp, body)
def create_port_forwarding(self, fip_id, internal_port_id,
internal_port, external_port,
internal_ip_address=None, protocol='tcp'):
post_body = {'port_forwarding': {
'protocol': protocol,
'internal_port_id': internal_port_id,
'internal_port': int(internal_port),
'external_port': int(external_port)}}
if internal_ip_address:
post_body['port_forwarding']['internal_ip_address'] = (
internal_ip_address)
body = jsonutils.dumps(post_body)
uri = '%s/floatingips/%s/port_forwardings' % (self.uri_prefix, fip_id)
resp, body = self.post(uri, body)
self.expected_success(201, resp.status)
body = jsonutils.loads(body)
return service_client.ResponseBody(resp, body)
def get_port_forwarding(self, fip_id, pf_id):
uri = '%s/floatingips/%s/port_forwardings/%s' % (self.uri_prefix,
fip_id, pf_id)
get_resp, get_resp_body = self.get(uri)
self.expected_success(200, get_resp.status)
body = jsonutils.loads(get_resp_body)
return service_client.ResponseBody(get_resp, body)
def list_port_forwardings(self, fip_id):
uri = '%s/floatingips/%s/port_forwardings' % (self.uri_prefix, fip_id)
resp, body = self.get(uri)
self.expected_success(200, resp.status)
body = jsonutils.loads(body)
return service_client.ResponseBody(resp, body)
def update_port_forwarding(self, fip_id, pf_id, **kwargs):
uri = '%s/floatingips/%s/port_forwardings/%s' % (self.uri_prefix,
fip_id, pf_id)
put_body = jsonutils.dumps({'port_forwarding': kwargs})
put_resp, resp_body = self.put(uri, put_body)
self.expected_success(200, put_resp.status)
body = jsonutils.loads(resp_body)
return service_client.ResponseBody(put_resp, body)
def delete_port_forwarding(self, fip_id, pf_id):
uri = '%s/floatingips/%s/port_forwardings/%s' % (self.uri_prefix,
fip_id, pf_id)
resp, body = self.delete(uri)
self.expected_success(204, resp.status)
service_client.ResponseBody(resp, body)
def create_network_keystone_v3(self, name, project_id, tenant_id=None):
uri = '%s/networks' % self.uri_prefix
post_data = {