Nova net functional tests round 3

* network segment
* network service
* port
* router
* security group
* security group rule
* subnet
* subnet pool
* extension
  The extension tests were duplicated to have both compute and network
  extensions tests so the nova-net case will still exercise the extension
  commands.

Also clean up formatting from previous reviews to make the Network functional
tests look and act consistently.

Change-Id: I286c40572faa31ddcef595cec740da933b2defc1
This commit is contained in:
Dean Troyer 2017-04-28 12:41:57 -05:00
parent efcf3b22ad
commit 190711ecd7
16 changed files with 389 additions and 175 deletions

@ -18,25 +18,66 @@ import json
from openstackclient.tests.functional import base from openstackclient.tests.functional import base
class TestExtension(base.TestCase): class ExtensionTests(base.TestCase):
"""Functional tests for extension.""" """Functional tests for extension"""
def test_extension_list(self): @classmethod
"""Test extension list.""" def setUpClass(cls):
# super(NetworkTests, cls).setUp()
cls.haz_network = base.is_service_enabled('network')
def test_extension_list_compute(self):
"""Test compute extension list"""
json_output = json.loads(self.openstack( json_output = json.loads(self.openstack(
'extension list -f json ' + '--network') 'extension list -f json ' +
) '--compute'
self.assertEqual( ))
'Default Subnetpools', name_list = [item.get('Name') for item in json_output]
json_output[0]['Name'], self.assertIn(
'ImageSize',
name_list,
) )
def test_extension_show(self): def test_extension_list_network(self):
"""Test extension show.""" """Test network extension list"""
if not self.haz_network:
self.skipTest("No Network service present")
json_output = json.loads(self.openstack(
'extension list -f json ' +
'--network'
))
name_list = [item.get('Name') for item in json_output]
self.assertIn(
'Default Subnetpools',
name_list,
)
# NOTE(dtroyer): Only network extensions are currently supported but
# I am going to leave this here anyway as a reminder
# fix that.
# def test_extension_show_compute(self):
# """Test compute extension show"""
# json_output = json.loads(self.openstack(
# 'extension show -f json ' +
# 'ImageSize'
# ))
# self.assertEqual(
# 'OS-EXT-IMG-SIZE',
# json_output.get('Alias'),
# )
def test_extension_show_network(self):
"""Test network extension show"""
if not self.haz_network:
self.skipTest("No Network service present")
name = 'agent' name = 'agent'
json_output = json.loads(self.openstack( json_output = json.loads(self.openstack(
'extension show -f json ' + name) 'extension show -f json ' +
) name
))
self.assertEqual( self.assertEqual(
name, name,
json_output.get('Alias')) json_output.get('Alias'),
)

@ -15,6 +15,7 @@ import uuid
from tempest.lib import exceptions from tempest.lib import exceptions
from openstackclient.tests.functional import base
from openstackclient.tests.functional.compute.v2 import common from openstackclient.tests.functional.compute.v2 import common
from openstackclient.tests.functional.volume.v2 import test_volume from openstackclient.tests.functional.volume.v2 import test_volume
@ -22,6 +23,10 @@ from openstackclient.tests.functional.volume.v2 import test_volume
class ServerTests(common.ComputeTestCase): class ServerTests(common.ComputeTestCase):
"""Functional tests for openstack server commands""" """Functional tests for openstack server commands"""
@classmethod
def setUpClass(cls):
cls.haz_network = base.is_service_enabled('network')
def test_server_list(self): def test_server_list(self):
"""Test server list, set""" """Test server list, set"""
cmd_output = self.server_create() cmd_output = self.server_create()
@ -202,6 +207,15 @@ class ServerTests(common.ComputeTestCase):
name = cmd_output['name'] name = cmd_output['name']
self.wait_for_status(name, "ACTIVE") self.wait_for_status(name, "ACTIVE")
if not self.haz_network:
# nova-net needs a public subnet
cmd_output = json.loads(self.openstack(
'network create -f json ' +
'--subnet 8.6.7.5/28 ' +
'public'
))
self.addCleanup(self.openstack, 'network delete public')
# attach ip # attach ip
cmd_output = json.loads(self.openstack( cmd_output = json.loads(self.openstack(
'floating ip create -f json ' + 'floating ip create -f json ' +

@ -17,7 +17,7 @@ from openstackclient.tests.functional.network.v2 import common
class AddressScopeTests(common.NetworkTests): class AddressScopeTests(common.NetworkTests):
"""Functional tests for address scope. """ """Functional tests for address scope"""
# NOTE(dtroyer): Do not normalize the setup and teardown of the resource # NOTE(dtroyer): Do not normalize the setup and teardown of the resource
# creation and deletion. Little is gained when each test # creation and deletion. Little is gained when each test

@ -17,31 +17,46 @@ from openstackclient.tests.functional.network.v2 import common
class IPAvailabilityTests(common.NetworkTests): class IPAvailabilityTests(common.NetworkTests):
"""Functional tests for IP availability. """ """Functional tests for IP availability"""
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
common.NetworkTests.setUpClass() common.NetworkTests.setUpClass()
if not cls.haz_network: if cls.haz_network:
common.NetworkTests.skipTest(cls, "No Network service present") # Create a network for the subnet.
cls.NAME = uuid.uuid4().hex
# Create a network for the subnet. cls.NETWORK_NAME = uuid.uuid4().hex
cls.NAME = uuid.uuid4().hex cls.openstack(
cls.NETWORK_NAME = uuid.uuid4().hex 'network create ' +
cls.openstack('network create ' + cls.NETWORK_NAME) cls.NETWORK_NAME
cmd_output = json.loads(cls.openstack( )
'subnet create -f json --network ' + cls.NETWORK_NAME + cmd_output = json.loads(cls.openstack(
' --subnet-range 10.10.10.0/24 ' + 'subnet create -f json ' +
cls.NAME '--network ' + cls.NETWORK_NAME + ' ' +
)) '--subnet-range 10.10.10.0/24 ' +
cls.assertOutput(cls.NAME, cmd_output['name']) cls.NAME
))
cls.assertOutput(cls.NAME, cmd_output['name'])
@classmethod @classmethod
def tearDownClass(cls): def tearDownClass(cls):
raw_subnet = cls.openstack('subnet delete ' + cls.NAME) if cls.haz_network:
raw_network = cls.openstack('network delete ' + cls.NETWORK_NAME) raw_subnet = cls.openstack(
cls.assertOutput('', raw_subnet) 'subnet delete ' +
cls.assertOutput('', raw_network) cls.NAME
)
raw_network = cls.openstack(
'network delete ' +
cls.NETWORK_NAME
)
cls.assertOutput('', raw_subnet)
cls.assertOutput('', raw_network)
def setUp(self):
super(IPAvailabilityTests, self).setUp()
# Nothing in this class works with Nova Network
if not self.haz_network:
self.skipTest("No Network service present")
def test_ip_availability_list(self): def test_ip_availability_list(self):
"""Test ip availability list""" """Test ip availability list"""

@ -13,17 +13,17 @@
import json import json
import uuid import uuid
from openstackclient.tests.functional import base from openstackclient.tests.functional.network.v2 import common
class NetworkTests(base.TestCase): class NetworkTests(common.NetworkTests):
"""Functional tests for network""" """Functional tests for network"""
@classmethod def setUp(self):
def setUpClass(cls): super(NetworkTests, self).setUp()
cls.haz_network = base.is_service_enabled('network') # Nothing in this class works with Nova Network
cls.PROJECT_NAME =\ if not self.haz_network:
cls.get_openstack_configuration_value('auth.project_name') self.skipTest("No Network service present")
def test_network_create_compute(self): def test_network_create_compute(self):
"""Test Nova-net create options, delete""" """Test Nova-net create options, delete"""

@ -31,7 +31,8 @@ class TestMeterRule(common.NetworkTests):
common.NetworkTests.setUpClass() common.NetworkTests.setUpClass()
if cls.haz_network: if cls.haz_network:
json_output = json.loads(cls.openstack( json_output = json.loads(cls.openstack(
'network meter create -f json ' + cls.METER_NAME 'network meter create -f json ' +
cls.METER_NAME
)) ))
cls.METER_ID = json_output.get('id') cls.METER_ID = json_output.get('id')
@ -39,7 +40,10 @@ class TestMeterRule(common.NetworkTests):
def tearDownClass(cls): def tearDownClass(cls):
common.NetworkTests.tearDownClass() common.NetworkTests.tearDownClass()
if cls.haz_network: if cls.haz_network:
raw_output = cls.openstack('network meter delete ' + cls.METER_ID) raw_output = cls.openstack(
'network meter delete ' +
cls.METER_ID
)
cls.assertOutput('', raw_output) cls.assertOutput('', raw_output)
def setUp(self): def setUp(self):

@ -27,10 +27,23 @@ class NetworkQosPolicyTests(common.NetworkTests):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
common.NetworkTests.setUpClass() common.NetworkTests.setUpClass()
opts = cls.get_opts(cls.FIELDS) if cls.haz_network:
raw_output = cls.openstack('network qos policy create ' + cls.NAME + opts = cls.get_opts(cls.FIELDS)
opts) raw_output = cls.openstack(
cls.assertOutput(cls.NAME + "\n", raw_output) 'network qos policy create ' +
cls.NAME +
opts
)
cls.assertOutput(cls.NAME + "\n", raw_output)
@classmethod
def tearDownClass(cls):
if cls.haz_network:
raw_output = cls.openstack(
'network qos policy delete ' +
cls.NAME
)
cls.assertOutput('', raw_output)
def setUp(self): def setUp(self):
super(NetworkQosPolicyTests, self).setUp() super(NetworkQosPolicyTests, self).setUp()
@ -38,11 +51,6 @@ class NetworkQosPolicyTests(common.NetworkTests):
if not self.haz_network: if not self.haz_network:
self.skipTest("No Network service present") self.skipTest("No Network service present")
@classmethod
def tearDownClass(cls):
raw_output = cls.openstack('network qos policy delete ' + cls.NAME)
cls.assertOutput('', raw_output)
def test_qos_policy_list(self): def test_qos_policy_list(self):
opts = self.get_opts(self.HEADERS) opts = self.get_opts(self.HEADERS)
raw_output = self.openstack('network qos policy list' + opts) raw_output = self.openstack('network qos policy list' + opts)

@ -19,7 +19,7 @@ from openstackclient.tests.functional.network.v2 import common
class NetworkQosRuleTestsMinimumBandwidth(common.NetworkTests): class NetworkQosRuleTestsMinimumBandwidth(common.NetworkTests):
"""Functional tests for QoS minimum bandwidth rule.""" """Functional tests for QoS minimum bandwidth rule"""
RULE_ID = None RULE_ID = None
QOS_POLICY_NAME = 'qos_policy_' + uuid.uuid4().hex QOS_POLICY_NAME = 'qos_policy_' + uuid.uuid4().hex
MIN_KBPS = 2800 MIN_KBPS = 2800
@ -32,20 +32,35 @@ class NetworkQosRuleTestsMinimumBandwidth(common.NetworkTests):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
common.NetworkTests.setUpClass() common.NetworkTests.setUpClass()
opts = cls.get_opts(cls.FIELDS) if cls.haz_network:
cls.openstack('network qos policy create ' + cls.QOS_POLICY_NAME) opts = cls.get_opts(cls.FIELDS)
cls.RULE_ID = cls.openstack('network qos rule create --type ' + cls.openstack(
cls.TYPE + ' --min-kbps ' + 'network qos policy create ' +
str(cls.MIN_KBPS) + ' ' + cls.DIRECTION + cls.QOS_POLICY_NAME
' ' + cls.QOS_POLICY_NAME + opts) )
cls.assertsOutputNotNone(cls.RULE_ID) cls.RULE_ID = cls.openstack(
'network qos rule create ' +
'--type ' + cls.TYPE + ' ' +
'--min-kbps ' + str(cls.MIN_KBPS) + ' ' +
cls.DIRECTION + ' ' +
cls.QOS_POLICY_NAME +
opts
)
cls.assertsOutputNotNone(cls.RULE_ID)
@classmethod @classmethod
def tearDownClass(cls): def tearDownClass(cls):
raw_output = cls.openstack('network qos rule delete ' + if cls.haz_network:
cls.QOS_POLICY_NAME + ' ' + cls.RULE_ID) raw_output = cls.openstack(
cls.openstack('network qos policy delete ' + cls.QOS_POLICY_NAME) 'network qos rule delete ' +
cls.assertOutput('', raw_output) cls.QOS_POLICY_NAME + ' ' +
cls.RULE_ID
)
cls.openstack(
'network qos policy delete ' +
cls.QOS_POLICY_NAME
)
cls.assertOutput('', raw_output)
def setUp(self): def setUp(self):
super(NetworkQosRuleTestsMinimumBandwidth, self).setUp() super(NetworkQosRuleTestsMinimumBandwidth, self).setUp()
@ -78,7 +93,7 @@ class NetworkQosRuleTestsMinimumBandwidth(common.NetworkTests):
class NetworkQosRuleTestsDSCPMarking(common.NetworkTests): class NetworkQosRuleTestsDSCPMarking(common.NetworkTests):
"""Functional tests for QoS DSCP marking rule.""" """Functional tests for QoS DSCP marking rule"""
RULE_ID = None RULE_ID = None
QOS_POLICY_NAME = 'qos_policy_' + uuid.uuid4().hex QOS_POLICY_NAME = 'qos_policy_' + uuid.uuid4().hex
DSCP_MARK = 8 DSCP_MARK = 8
@ -90,20 +105,31 @@ class NetworkQosRuleTestsDSCPMarking(common.NetworkTests):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
common.NetworkTests.setUpClass() common.NetworkTests.setUpClass()
opts = cls.get_opts(cls.FIELDS) if cls.haz_network:
cls.openstack('network qos policy create ' + cls.QOS_POLICY_NAME) opts = cls.get_opts(cls.FIELDS)
cls.RULE_ID = cls.openstack('network qos rule create --type ' + cls.openstack(
cls.TYPE + ' --dscp-mark ' + 'network qos policy create ' +
str(cls.DSCP_MARK) + ' ' + cls.QOS_POLICY_NAME
cls.QOS_POLICY_NAME + opts) )
cls.assertsOutputNotNone(cls.RULE_ID) cls.RULE_ID = cls.openstack(
'network qos rule create ' +
'--type ' + cls.TYPE + ' ' +
'--dscp-mark ' + str(cls.DSCP_MARK) + ' ' +
cls.QOS_POLICY_NAME +
opts
)
cls.assertsOutputNotNone(cls.RULE_ID)
@classmethod @classmethod
def tearDownClass(cls): def tearDownClass(cls):
raw_output = cls.openstack('network qos rule delete ' + if cls.haz_network:
cls.QOS_POLICY_NAME + ' ' + cls.RULE_ID) raw_output = cls.openstack(
cls.openstack('network qos policy delete ' + cls.QOS_POLICY_NAME) 'network qos rule delete ' +
cls.assertOutput('', raw_output) cls.QOS_POLICY_NAME + ' ' +
cls.RULE_ID
)
cls.openstack('network qos policy delete ' + cls.QOS_POLICY_NAME)
cls.assertOutput('', raw_output)
def setUp(self): def setUp(self):
super(NetworkQosRuleTestsDSCPMarking, self).setUp() super(NetworkQosRuleTestsDSCPMarking, self).setUp()
@ -136,7 +162,7 @@ class NetworkQosRuleTestsDSCPMarking(common.NetworkTests):
class NetworkQosRuleTestsBandwidthLimit(common.NetworkTests): class NetworkQosRuleTestsBandwidthLimit(common.NetworkTests):
"""Functional tests for QoS bandwidth limit rule.""" """Functional tests for QoS bandwidth limit rule"""
RULE_ID = None RULE_ID = None
QOS_POLICY_NAME = 'qos_policy_' + uuid.uuid4().hex QOS_POLICY_NAME = 'qos_policy_' + uuid.uuid4().hex
MAX_KBPS = 10000 MAX_KBPS = 10000
@ -150,21 +176,32 @@ class NetworkQosRuleTestsBandwidthLimit(common.NetworkTests):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
common.NetworkTests.setUpClass() common.NetworkTests.setUpClass()
opts = cls.get_opts(cls.FIELDS) if cls.haz_network:
cls.openstack('network qos policy create ' + cls.QOS_POLICY_NAME) opts = cls.get_opts(cls.FIELDS)
cls.RULE_ID = cls.openstack('network qos rule create --type ' + cls.openstack(
cls.TYPE + ' --max-kbps ' + 'network qos policy create ' +
str(cls.MAX_KBPS) + ' --max-burst-kbits ' + cls.QOS_POLICY_NAME
str(cls.MAX_BURST_KBITS) + ' ' + )
cls.QOS_POLICY_NAME + opts) cls.RULE_ID = cls.openstack(
cls.assertsOutputNotNone(cls.RULE_ID) 'network qos rule create ' +
'--type ' + cls.TYPE + ' ' +
'--max-kbps ' + str(cls.MAX_KBPS) + ' ' +
'--max-burst-kbits ' + str(cls.MAX_BURST_KBITS) + ' ' +
cls.QOS_POLICY_NAME +
opts
)
cls.assertsOutputNotNone(cls.RULE_ID)
@classmethod @classmethod
def tearDownClass(cls): def tearDownClass(cls):
raw_output = cls.openstack('network qos rule delete ' + if cls.haz_network:
cls.QOS_POLICY_NAME + ' ' + cls.RULE_ID) raw_output = cls.openstack(
cls.openstack('network qos policy delete ' + cls.QOS_POLICY_NAME) 'network qos rule delete ' +
cls.assertOutput('', raw_output) cls.QOS_POLICY_NAME + ' ' +
cls.RULE_ID
)
cls.openstack('network qos policy delete ' + cls.QOS_POLICY_NAME)
cls.assertOutput('', raw_output)
def setUp(self): def setUp(self):
super(NetworkQosRuleTestsBandwidthLimit, self).setUp() super(NetworkQosRuleTestsBandwidthLimit, self).setUp()

@ -12,11 +12,11 @@
import uuid import uuid
from openstackclient.tests.functional import base from openstackclient.tests.functional.network.v2 import common
class NetworkSegmentTests(base.TestCase): class NetworkSegmentTests(common.NetworkTests):
"""Functional tests for network segment. """ """Functional tests for network segment"""
NETWORK_NAME = uuid.uuid4().hex NETWORK_NAME = uuid.uuid4().hex
PHYSICAL_NETWORK_NAME = uuid.uuid4().hex PHYSICAL_NETWORK_NAME = uuid.uuid4().hex
NETWORK_SEGMENT_ID = None NETWORK_SEGMENT_ID = None
@ -25,30 +25,46 @@ class NetworkSegmentTests(base.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
# Create a network for the segment. common.NetworkTests.setUpClass()
opts = cls.get_opts(['id']) if cls.haz_network:
raw_output = cls.openstack('network create ' + cls.NETWORK_NAME + opts) # Create a network for the segment.
cls.NETWORK_ID = raw_output.strip('\n') opts = cls.get_opts(['id'])
raw_output = cls.openstack(
'network create ' + cls.NETWORK_NAME + opts
)
cls.NETWORK_ID = raw_output.strip('\n')
# NOTE(rtheis): The segment extension is not yet enabled by default. # NOTE(rtheis): The segment extension is not yet enabled
# Skip the tests if not enabled. # by default.
extensions = cls.get_openstack_extention_names() # Skip the tests if not enabled.
if 'Segment' in extensions: extensions = cls.get_openstack_extention_names()
cls.NETWORK_SEGMENT_EXTENSION = 'Segment' if 'Segment' in extensions:
cls.NETWORK_SEGMENT_EXTENSION = 'Segment'
if cls.NETWORK_SEGMENT_EXTENSION: if cls.NETWORK_SEGMENT_EXTENSION:
# Get the segment for the network. # Get the segment for the network.
opts = cls.get_opts(['ID', 'Network']) opts = cls.get_opts(['ID', 'Network'])
raw_output = cls.openstack('network segment list ' raw_output = cls.openstack(
' --network ' + cls.NETWORK_NAME + 'network segment list '
' ' + opts) '--network ' + cls.NETWORK_NAME + ' ' +
raw_output_row = raw_output.split('\n')[0] opts
cls.NETWORK_SEGMENT_ID = raw_output_row.split(' ')[0] )
raw_output_row = raw_output.split('\n')[0]
cls.NETWORK_SEGMENT_ID = raw_output_row.split(' ')[0]
@classmethod @classmethod
def tearDownClass(cls): def tearDownClass(cls):
raw_output = cls.openstack('network delete ' + cls.NETWORK_NAME) if cls.haz_network:
cls.assertOutput('', raw_output) raw_output = cls.openstack(
'network delete ' + cls.NETWORK_NAME
)
cls.assertOutput('', raw_output)
def setUp(self):
super(NetworkSegmentTests, self).setUp()
# Nothing in this class works with Nova Network
if not self.haz_network:
self.skipTest("No Network service present")
def test_network_segment_create_delete(self): def test_network_segment_create_delete(self):
if self.NETWORK_SEGMENT_EXTENSION: if self.NETWORK_SEGMENT_EXTENSION:

@ -13,14 +13,20 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
from openstackclient.tests.functional import base from openstackclient.tests.functional.network.v2 import common
class TestNetworkServiceProvider(base.TestCase): class TestNetworkServiceProvider(common.NetworkTests):
"""Functional tests for network service provider""" """Functional tests for network service provider"""
SERVICE_TYPE = 'L3_ROUTER_NAT' SERVICE_TYPE = 'L3_ROUTER_NAT'
def setUp(self):
super(TestNetworkServiceProvider, self).setUp()
# Nothing in this class works with Nova Network
if not self.haz_network:
self.skipTest("No Network service present")
def test_network_service_provider_list(self): def test_network_service_provider_list(self):
raw_output = self.openstack('network service provider list') raw_output = self.openstack('network service provider list')
self.assertIn(self.SERVICE_TYPE, raw_output) self.assertIn(self.SERVICE_TYPE, raw_output)

@ -13,23 +13,36 @@
import json import json
import uuid import uuid
from openstackclient.tests.functional import base from openstackclient.tests.functional.network.v2 import common
class PortTests(base.TestCase): class PortTests(common.NetworkTests):
"""Functional tests for port. """ """Functional tests for port"""
NAME = uuid.uuid4().hex NAME = uuid.uuid4().hex
NETWORK_NAME = uuid.uuid4().hex NETWORK_NAME = uuid.uuid4().hex
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
# Create a network for the port common.NetworkTests.setUpClass()
cls.openstack('network create ' + cls.NETWORK_NAME) if cls.haz_network:
# Create a network for the port
cls.openstack(
'network create ' + cls.NETWORK_NAME
)
@classmethod @classmethod
def tearDownClass(cls): def tearDownClass(cls):
raw_output = cls.openstack('network delete ' + cls.NETWORK_NAME) if cls.haz_network:
cls.assertOutput('', raw_output) raw_output = cls.openstack(
'network delete ' + cls.NETWORK_NAME
)
cls.assertOutput('', raw_output)
def setUp(self):
super(PortTests, self).setUp()
# Nothing in this class works with Nova Network
if not self.haz_network:
self.skipTest("No Network service present")
def test_port_delete(self): def test_port_delete(self):
"""Test create, delete multiple""" """Test create, delete multiple"""

@ -13,11 +13,17 @@
import json import json
import uuid import uuid
from openstackclient.tests.functional import base from openstackclient.tests.functional.network.v2 import common
class RouterTests(base.TestCase): class RouterTests(common.NetworkTests):
"""Functional tests for router. """ """Functional tests for router"""
def setUp(self):
super(RouterTests, self).setUp()
# Nothing in this class works with Nova Network
if not self.haz_network:
self.skipTest("No Network service present")
def test_router_create_and_delete(self): def test_router_create_and_delete(self):
"""Test create options, delete multiple""" """Test create options, delete multiple"""

@ -12,11 +12,11 @@
import uuid import uuid
from openstackclient.tests.functional import base from openstackclient.tests.functional.network.v2 import common
class SecurityGroupTests(base.TestCase): class SecurityGroupTests(common.NetworkTests):
"""Functional tests for security group. """ """Functional tests for security group"""
NAME = uuid.uuid4().hex NAME = uuid.uuid4().hex
OTHER_NAME = uuid.uuid4().hex OTHER_NAME = uuid.uuid4().hex
HEADERS = ['Name'] HEADERS = ['Name']
@ -24,20 +24,39 @@ class SecurityGroupTests(base.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
opts = cls.get_opts(cls.FIELDS) common.NetworkTests.setUpClass()
raw_output = cls.openstack('security group create ' + cls.NAME + opts) if cls.haz_network:
expected = cls.NAME + '\n' opts = cls.get_opts(cls.FIELDS)
cls.assertOutput(expected, raw_output) raw_output = cls.openstack(
'security group create ' +
cls.NAME +
opts
)
expected = cls.NAME + '\n'
cls.assertOutput(expected, raw_output)
@classmethod @classmethod
def tearDownClass(cls): def tearDownClass(cls):
# Rename test if cls.haz_network:
raw_output = cls.openstack('security group set --name ' + # Rename test
cls.OTHER_NAME + ' ' + cls.NAME) raw_output = cls.openstack(
cls.assertOutput('', raw_output) 'security group set --name ' +
# Delete test cls.OTHER_NAME + ' ' +
raw_output = cls.openstack('security group delete ' + cls.OTHER_NAME) cls.NAME
cls.assertOutput('', raw_output) )
cls.assertOutput('', raw_output)
# Delete test
raw_output = cls.openstack(
'security group delete ' +
cls.OTHER_NAME
)
cls.assertOutput('', raw_output)
def setUp(self):
super(SecurityGroupTests, self).setUp()
# Nothing in this class works with Nova Network
if not self.haz_network:
self.skipTest("No Network service present")
def test_security_group_list(self): def test_security_group_list(self):
opts = self.get_opts(self.HEADERS) opts = self.get_opts(self.HEADERS)

@ -12,11 +12,11 @@
import uuid import uuid
from openstackclient.tests.functional import base from openstackclient.tests.functional.network.v2 import common
class SecurityGroupRuleTests(base.TestCase): class SecurityGroupRuleTests(common.NetworkTests):
"""Functional tests for security group rule. """ """Functional tests for security group rule"""
SECURITY_GROUP_NAME = uuid.uuid4().hex SECURITY_GROUP_NAME = uuid.uuid4().hex
SECURITY_GROUP_RULE_ID = None SECURITY_GROUP_RULE_ID = None
NAME_FIELD = ['name'] NAME_FIELD = ['name']
@ -25,32 +25,49 @@ class SecurityGroupRuleTests(base.TestCase):
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
# Create the security group to hold the rule. common.NetworkTests.setUpClass()
opts = cls.get_opts(cls.NAME_FIELD) if cls.haz_network:
raw_output = cls.openstack('security group create ' + # Create the security group to hold the rule.
cls.SECURITY_GROUP_NAME + opts = cls.get_opts(cls.NAME_FIELD)
opts) raw_output = cls.openstack(
expected = cls.SECURITY_GROUP_NAME + '\n' 'security group create ' +
cls.assertOutput(expected, raw_output) cls.SECURITY_GROUP_NAME +
opts
)
expected = cls.SECURITY_GROUP_NAME + '\n'
cls.assertOutput(expected, raw_output)
# Create the security group rule. # Create the security group rule.
opts = cls.get_opts(cls.ID_FIELD) opts = cls.get_opts(cls.ID_FIELD)
raw_output = cls.openstack('security group rule create ' + raw_output = cls.openstack(
cls.SECURITY_GROUP_NAME + 'security group rule create ' +
' --protocol tcp --dst-port 80:80' + cls.SECURITY_GROUP_NAME + ' ' +
' --ingress --ethertype IPv4' + '--protocol tcp --dst-port 80:80 ' +
opts) '--ingress --ethertype IPv4 ' +
cls.SECURITY_GROUP_RULE_ID = raw_output.strip('\n') opts
)
cls.SECURITY_GROUP_RULE_ID = raw_output.strip('\n')
@classmethod @classmethod
def tearDownClass(cls): def tearDownClass(cls):
raw_output = cls.openstack('security group rule delete ' + if cls.haz_network:
cls.SECURITY_GROUP_RULE_ID) raw_output = cls.openstack(
cls.assertOutput('', raw_output) 'security group rule delete ' +
cls.SECURITY_GROUP_RULE_ID
)
cls.assertOutput('', raw_output)
raw_output = cls.openstack('security group delete ' + raw_output = cls.openstack(
cls.SECURITY_GROUP_NAME) 'security group delete ' +
cls.assertOutput('', raw_output) cls.SECURITY_GROUP_NAME
)
cls.assertOutput('', raw_output)
def setUp(self):
super(SecurityGroupRuleTests, self).setUp()
# Nothing in this class works with Nova Network
if not self.haz_network:
self.skipTest("No Network service present")
def test_security_group_rule_list(self): def test_security_group_rule_list(self):
opts = self.get_opts(self.ID_HEADER) opts = self.get_opts(self.ID_HEADER)

@ -14,27 +14,39 @@ import json
import random import random
import uuid import uuid
from openstackclient.tests.functional import base from openstackclient.tests.functional.network.v2 import common
class SubnetTests(base.TestCase): class SubnetTests(common.NetworkTests):
"""Functional tests for subnet. """ """Functional tests for subnet"""
@classmethod @classmethod
def setUpClass(cls): def setUpClass(cls):
# Create a network for the all subnet tests. common.NetworkTests.setUpClass()
cls.NETWORK_NAME = uuid.uuid4().hex if cls.haz_network:
cmd_output = json.loads(cls.openstack( # Create a network for the all subnet tests
'network create -f json ' + cls.NETWORK_NAME = uuid.uuid4().hex
cls.NETWORK_NAME cmd_output = json.loads(cls.openstack(
)) 'network create -f json ' +
# Get network_id for assertEqual cls.NETWORK_NAME
cls.NETWORK_ID = cmd_output["id"] ))
# Get network_id for assertEqual
cls.NETWORK_ID = cmd_output["id"]
@classmethod @classmethod
def tearDownClass(cls): def tearDownClass(cls):
raw_output = cls.openstack('network delete ' + cls.NETWORK_NAME) if cls.haz_network:
cls.assertOutput('', raw_output) raw_output = cls.openstack(
'network delete ' +
cls.NETWORK_NAME
)
cls.assertOutput('', raw_output)
def setUp(self):
super(SubnetTests, self).setUp()
# Nothing in this class works with Nova Network
if not self.haz_network:
self.skipTest("No Network service present")
def test_subnet_create_and_delete(self): def test_subnet_create_and_delete(self):
"""Test create, delete multiple""" """Test create, delete multiple"""

@ -14,12 +14,18 @@ import json
import random import random
import uuid import uuid
from openstackclient.tests.functional import base from openstackclient.tests.functional.network.v2 import common
class SubnetPoolTests(base.TestCase): class SubnetPoolTests(common.NetworkTests):
"""Functional tests for subnet pool""" """Functional tests for subnet pool"""
def setUp(self):
super(SubnetPoolTests, self).setUp()
# Nothing in this class works with Nova Network
if not self.haz_network:
self.skipTest("No Network service present")
def test_subnet_pool_create_delete(self): def test_subnet_pool_create_delete(self):
"""Test create, delete""" """Test create, delete"""
name1 = uuid.uuid4().hex name1 = uuid.uuid4().hex