openstack/openstacksdk
Code Issues Proposed changes

Migrate to testtools for functional tests

Browse Source 
The standard in OpenStack is to use testtools not unittest. Use the base
test class which is based on testtools. This class also sets up loggers
appropriately.

unittest has an assertEqual method that is more appropriate.
Replace use of equal comparisons to None with assertIsNone.
Replace use of setUpClass and tearDownClass with setUp and tearDown.

Change-Id: Ie0f47dc7c0905164030953ba2d2633bd095782ca
This commit is contained in:
Monty Taylor
2017-11-10 16:41:01 +11:00
parent 240f5911d2
commit a25f8f3518
51 changed files with 876 additions and 975 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.zuul.yaml
View File

@@ -227,7 +227,6 @@
- openstacksdk-ansible-devel-functional-devstack - openstacksdk-ansible-devel-functional-devstack
- openstacksdk-ansible-functional-devstack - openstacksdk-ansible-functional-devstack
- openstacksdk-functional-devstack - openstacksdk-functional-devstack
- openstacksdk-functional-devstack-legacy
- openstacksdk-functional-devstack-magnum - openstacksdk-functional-devstack-magnum
- openstacksdk-functional-devstack-python3 - openstacksdk-functional-devstack-python3
gate: gate:

5
openstack/tests/base.py
View File

@@ -13,9 +13,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
# TODO(shade) Remove all use of setUpClass and tearDownClass. setUp and
# addCleanup should be used instead.
import os import os
import fixtures import fixtures
@@ -69,7 +66,7 @@ class TestCase(testtools.TestCase):
formatter = logging.Formatter('%(asctime)s %(name)-32s %(message)s') formatter = logging.Formatter('%(asctime)s %(name)-32s %(message)s')
handler.setFormatter(formatter) handler.setFormatter(formatter)
logger = logging.getLogger('shade') logger = logging.getLogger('openstack')
logger.setLevel(logging.DEBUG) logger.setLevel(logging.DEBUG)
logger.addHandler(handler) logger.addHandler(handler)

10
openstack/tests/examples/test_compute.py
View File

@@ -10,7 +10,7 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import unittest import testtools
from examples.compute import create from examples.compute import create
from examples.compute import delete from examples.compute import delete
@@ -21,16 +21,16 @@ from examples.network import find as network_find
from examples.network import list as network_list from examples.network import list as network_list
class TestCompute(unittest.TestCase): class TestCompute(testtools.TestCase):
"""Test the compute examples """Test the compute examples
The purpose of these tests is to ensure the examples run without erring The purpose of these tests is to ensure the examples run without erring
out. out.
""" """
@classmethod def setUp(self):
def setUpClass(cls): super(TestCompute, self).setUp()
cls.conn = connect.create_connection_from_config() self.conn = connect.create_connection_from_config()
def test_compute(self): def test_compute(self):
compute_list.list_servers(self.conn) compute_list.list_servers(self.conn)

10
openstack/tests/examples/test_identity.py
View File

@@ -10,22 +10,22 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import unittest import testtools
from examples import connect from examples import connect
from examples.identity import list as identity_list from examples.identity import list as identity_list
class TestIdentity(unittest.TestCase): class TestIdentity(testtools.TestCase):
"""Test the identity examples """Test the identity examples
The purpose of these tests is to ensure the examples run without erring The purpose of these tests is to ensure the examples run without erring
out. out.
""" """
@classmethod def setUp(self):
def setUpClass(cls): super(TestIdentity, self).setUp()
cls.conn = connect.create_connection_from_config() self.conn = connect.create_connection_from_config()
def test_identity(self): def test_identity(self):
identity_list.list_users(self.conn) identity_list.list_users(self.conn)

10
openstack/tests/examples/test_image.py
View File

@@ -10,7 +10,7 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import unittest import testtools
from examples import connect from examples import connect
from examples.image import create as image_create from examples.image import create as image_create
@@ -18,16 +18,16 @@ from examples.image import delete as image_delete
from examples.image import list as image_list from examples.image import list as image_list
class TestImage(unittest.TestCase): class TestImage(testtools.TestCase):
"""Test the image examples """Test the image examples
The purpose of these tests is to ensure the examples run without erring The purpose of these tests is to ensure the examples run without erring
out. out.
""" """
@classmethod def setUp(self):
def setUpClass(cls): super(TestImage, self).setUp()
cls.conn = connect.create_connection_from_config() self.conn = connect.create_connection_from_config()
def test_image(self): def test_image(self):
image_list.list_images(self.conn) image_list.list_images(self.conn)

10
openstack/tests/examples/test_network.py
View File

@@ -10,7 +10,7 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import unittest import testtools
from examples import connect from examples import connect
from examples.network import create as network_create from examples.network import create as network_create
@@ -19,16 +19,16 @@ from examples.network import find as network_find
from examples.network import list as network_list from examples.network import list as network_list
class TestNetwork(unittest.TestCase): class TestNetwork(testtools.TestCase):
"""Test the network examples """Test the network examples
The purpose of these tests is to ensure the examples run without erring The purpose of these tests is to ensure the examples run without erring
out. out.
""" """
@classmethod def setUp(self):
def setUpClass(cls): super(TestNetwork, self).setUp()
cls.conn = connect.create_connection_from_config() self.conn = connect.create_connection_from_config()
def test_network(self): def test_network(self):
network_list.list_networks(self.conn) network_list.list_networks(self.conn)

59
openstack/tests/functional/base.py
View File

@@ -12,11 +12,10 @@
import os import os
import openstack.config import openstack.config
import time
import unittest
from keystoneauth1 import exceptions as _exceptions from keystoneauth1 import exceptions as _exceptions
from openstack import connection from openstack import connection
from openstack.tests import base
#: Defines the OpenStack Client Config (OCC) cloud key in your OCC config #: Defines the OpenStack Client Config (OCC) cloud key in your OCC config
@@ -46,38 +45,34 @@ IMAGE_NAME = _get_resource_value('image_name', 'cirros-0.3.5-x86_64-disk')
FLAVOR_NAME = _get_resource_value('flavor_name', 'm1.small') FLAVOR_NAME = _get_resource_value('flavor_name', 'm1.small')
def service_exists(**kwargs): class BaseFunctionalTest(base.TestCase):
"""Decorator function to check whether a service exists
Usage: def setUp(self):
@unittest.skipUnless(base.service_exists(service_type="metering"), super(BaseFunctionalTest, self).setUp()
"Metering service does not exist") self.conn = connection.from_config(cloud_name=TEST_CLOUD)
class TestMeter(base.BaseFunctionalTest):
...
:param kwargs: The kwargs needed to filter an endpoint. def addEmptyCleanup(self, func, *args, **kwargs):
:returns: True if the service exists, otherwise False. def cleanup():
""" result = func(*args, **kwargs)
try: self.assertIsNone(result)
conn = connection.from_config(cloud_name=TEST_CLOUD) self.addCleanup(cleanup)
conn.session.get_endpoint(**kwargs)
return True # TODO(shade) Replace this with call to conn.has_service when we've merged
except _exceptions.EndpointNotFound: # the shade methods into Connection.
return False def require_service(self, service_type, **kwargs):
"""Method to check whether a service exists
Usage:
class TestMeter(base.BaseFunctionalTest):
...
def setUp(self):
super(TestMeter, self).setUp()
self.require_service('metering')
class BaseFunctionalTest(unittest.TestCase): :returns: True if the service exists, otherwise False.
"""
@classmethod try:
def setUpClass(cls): self.conn.session.get_endpoint(service_type=service_type, **kwargs)
cls.conn = connection.from_config(cloud_name=TEST_CLOUD) except _exceptions.EndpointNotFound:
self.skipTest('Service {service_type} not found in cloud'.format(
@classmethod service_type=service_type))
def assertIs(cls, expected, actual):
if expected != actual:
raise Exception(expected + ' != ' + actual)
@classmethod
def linger_for_delete(cls):
time.sleep(40)

78
openstack/tests/functional/block_store/v2/test_snapshot.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.block_store.v2 import snapshot as _snapshot from openstack.block_store.v2 import snapshot as _snapshot
from openstack.block_store.v2 import volume as _volume from openstack.block_store.v2 import volume as _volume
@@ -19,49 +18,50 @@ from openstack.tests.functional import base
class TestSnapshot(base.BaseFunctionalTest): class TestSnapshot(base.BaseFunctionalTest):
SNAPSHOT_NAME = uuid.uuid4().hex def setUp(self):
SNAPSHOT_ID = None super(TestSnapshot, self).setUp()
VOLUME_NAME = uuid.uuid4().hex
VOLUME_ID = None
@classmethod self.SNAPSHOT_NAME = self.getUniqueString()
def setUpClass(cls): self.SNAPSHOT_ID = None
super(TestSnapshot, cls).setUpClass() self.VOLUME_NAME = self.getUniqueString()
volume = cls.conn.block_store.create_volume( self.VOLUME_ID = None
name=cls.VOLUME_NAME,
volume = self.conn.block_store.create_volume(
name=self.VOLUME_NAME,
size=1) size=1)
cls.conn.block_store.wait_for_status(volume, self.conn.block_store.wait_for_status(
status='available', volume,
failures=['error'], status='available',
interval=2, failures=['error'],
wait=120) interval=2,
wait=120)
assert isinstance(volume, _volume.Volume) assert isinstance(volume, _volume.Volume)
cls.assertIs(cls.VOLUME_NAME, volume.name) self.assertEqual(self.VOLUME_NAME, volume.name)
cls.VOLUME_ID = volume.id self.VOLUME_ID = volume.id
snapshot = cls.conn.block_store.create_snapshot( snapshot = self.conn.block_store.create_snapshot(
name=cls.SNAPSHOT_NAME, name=self.SNAPSHOT_NAME,
volume_id=cls.VOLUME_ID) volume_id=self.VOLUME_ID)
cls.conn.block_store.wait_for_status(snapshot, self.conn.block_store.wait_for_status(
status='available', snapshot,
failures=['error'], status='available',
interval=2, failures=['error'],
wait=120) interval=2,
wait=120)
assert isinstance(snapshot, _snapshot.Snapshot) assert isinstance(snapshot, _snapshot.Snapshot)
cls.assertIs(cls.SNAPSHOT_NAME, snapshot.name) self.assertEqual(self.SNAPSHOT_NAME, snapshot.name)
cls.SNAPSHOT_ID = snapshot.id self.SNAPSHOT_ID = snapshot.id
@classmethod def tearDown(self):
def tearDownClass(cls): snapshot = self.conn.block_store.get_snapshot(self.SNAPSHOT_ID)
snapshot = cls.conn.block_store.get_snapshot(cls.SNAPSHOT_ID) sot = self.conn.block_store.delete_snapshot(
sot = cls.conn.block_store.delete_snapshot(snapshot, snapshot, ignore_missing=False)
ignore_missing=False) self.conn.block_store.wait_for_delete(
cls.conn.block_store.wait_for_delete(snapshot, snapshot, interval=2, wait=120)
interval=2, self.assertIsNone(sot)
wait=120) sot = self.conn.block_store.delete_volume(
cls.assertIs(None, sot) self.VOLUME_ID, ignore_missing=False)
sot = cls.conn.block_store.delete_volume(cls.VOLUME_ID, self.assertIsNone(sot)
ignore_missing=False) super(TestSnapshot, self).tearDown()
cls.assertIs(None, sot)
def test_get(self): def test_get(self):
sot = self.conn.block_store.get_snapshot(self.SNAPSHOT_ID) sot = self.conn.block_store.get_snapshot(self.SNAPSHOT_ID)

27
openstack/tests/functional/block_store/v2/test_type.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.block_store.v2 import type as _type from openstack.block_store.v2 import type as _type
from openstack.tests.functional import base from openstack.tests.functional import base
@@ -18,22 +17,22 @@ from openstack.tests.functional import base
class TestType(base.BaseFunctionalTest): class TestType(base.BaseFunctionalTest):
TYPE_NAME = uuid.uuid4().hex def setUp(self):
TYPE_ID = None super(TestType, self).setUp()
@classmethod self.TYPE_NAME = self.getUniqueString()
def setUpClass(cls): self.TYPE_ID = None
super(TestType, cls).setUpClass()
sot = cls.conn.block_store.create_type(name=cls.TYPE_NAME) sot = self.conn.block_store.create_type(name=self.TYPE_NAME)
assert isinstance(sot, _type.Type) assert isinstance(sot, _type.Type)
cls.assertIs(cls.TYPE_NAME, sot.name) self.assertEqual(self.TYPE_NAME, sot.name)
cls.TYPE_ID = sot.id self.TYPE_ID = sot.id
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.block_store.delete_type(
sot = cls.conn.block_store.delete_type(cls.TYPE_ID, self.TYPE_ID, ignore_missing=False)
ignore_missing=False) self.assertIsNone(sot)
cls.assertIs(None, sot) super(TestType, self).tearDown()
def test_get(self): def test_get(self):
sot = self.conn.block_store.get_type(self.TYPE_ID) sot = self.conn.block_store.get_type(self.TYPE_ID)

41
openstack/tests/functional/block_store/v2/test_volume.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.block_store.v2 import volume as _volume from openstack.block_store.v2 import volume as _volume
from openstack.tests.functional import base from openstack.tests.functional import base
@@ -18,29 +17,31 @@ from openstack.tests.functional import base
class TestVolume(base.BaseFunctionalTest): class TestVolume(base.BaseFunctionalTest):
VOLUME_NAME = uuid.uuid4().hex def setUp(self):
VOLUME_ID = None super(TestVolume, self).setUp()
@classmethod self.VOLUME_NAME = self.getUniqueString()
def setUpClass(cls): self.VOLUME_ID = None
super(TestVolume, cls).setUpClass()
volume = cls.conn.block_store.create_volume( volume = self.conn.block_store.create_volume(
name=cls.VOLUME_NAME, name=self.VOLUME_NAME,
size=1) size=1)
cls.conn.block_store.wait_for_status(volume, self.conn.block_store.wait_for_status(
status='available', volume,
failures=['error'], status='available',
interval=2, failures=['error'],
wait=120) interval=2,
wait=120)
assert isinstance(volume, _volume.Volume) assert isinstance(volume, _volume.Volume)
cls.assertIs(cls.VOLUME_NAME, volume.name) self.assertEqual(self.VOLUME_NAME, volume.name)
cls.VOLUME_ID = volume.id self.VOLUME_ID = volume.id
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.block_store.delete_volume(
sot = cls.conn.block_store.delete_volume(cls.VOLUME_ID, self.VOLUME_ID,
ignore_missing=False) ignore_missing=False)
cls.assertIs(None, sot) self.assertIsNone(sot)
super(TestVolume, self).tearDown()
def test_get(self): def test_get(self):
sot = self.conn.block_store.get_volume(self.VOLUME_ID) sot = self.conn.block_store.get_volume(self.VOLUME_ID)

7
openstack/tests/functional/compute/v2/test_flavor.py
View File

@@ -18,11 +18,10 @@ from openstack.tests.functional import base
class TestFlavor(base.BaseFunctionalTest): class TestFlavor(base.BaseFunctionalTest):
@classmethod def setUp(self):
def setUpClass(cls): super(TestFlavor, self).setUp()
super(TestFlavor, cls).setUpClass()
cls.one_flavor = list(cls.conn.compute.flavors())[0] self.one_flavor = list(self.conn.compute.flavors())[0]
def test_flavors(self): def test_flavors(self):
flavors = list(self.conn.compute.flavors()) flavors = list(self.conn.compute.flavors())

28
openstack/tests/functional/compute/v2/test_keypair.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.compute.v2 import keypair from openstack.compute.v2 import keypair
from openstack.tests.functional import base from openstack.tests.functional import base
@@ -18,22 +17,23 @@ from openstack.tests.functional import base
class TestKeypair(base.BaseFunctionalTest): class TestKeypair(base.BaseFunctionalTest):
NAME = uuid.uuid4().hex def setUp(self):
ID = None super(TestKeypair, self).setUp()
@classmethod # Keypairs can't have .'s in the name. Because why?
def setUpClass(cls): self.NAME = self.getUniqueString().split('.')[-1]
super(TestKeypair, cls).setUpClass() self.ID = None
sot = cls.conn.compute.create_keypair(name=cls.NAME)
sot = self.conn.compute.create_keypair(name=self.NAME)
assert isinstance(sot, keypair.Keypair) assert isinstance(sot, keypair.Keypair)
cls.assertIs(cls.NAME, sot.name) self.assertEqual(self.NAME, sot.name)
cls._keypair = sot self._keypair = sot
cls.ID = sot.id self.ID = sot.id
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.compute.delete_keypair(self._keypair)
sot = cls.conn.compute.delete_keypair(cls._keypair) self.assertIsNone(sot)
cls.assertIs(None, sot) super(TestKeypair, self).tearDown()
def test_find(self): def test_find(self):
sot = self.conn.compute.find_keypair(self.NAME) sot = self.conn.compute.find_keypair(self.NAME)

65
openstack/tests/functional/compute/v2/test_server.py
View File

@@ -10,7 +10,7 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid import time
from openstack.compute.v2 import server from openstack.compute.v2 import server
from openstack.tests.functional import base from openstack.tests.functional import base
@@ -19,44 +19,41 @@ from openstack.tests.functional.network.v2 import test_network
class TestServer(base.BaseFunctionalTest): class TestServer(base.BaseFunctionalTest):
NAME = uuid.uuid4().hex def setUp(self):
server = None super(TestServer, self).setUp()
network = None self.NAME = self.getUniqueString()
subnet = None self.server = None
cidr = '10.99.99.0/16' self.network = None
self.subnet = None
self.cidr = '10.99.99.0/16'
@classmethod flavor = self.conn.compute.find_flavor(base.FLAVOR_NAME,
def setUpClass(cls): ignore_missing=False)
super(TestServer, cls).setUpClass() image = self.conn.compute.find_image(base.IMAGE_NAME,
flavor = cls.conn.compute.find_flavor(base.FLAVOR_NAME, ignore_missing=False)
ignore_missing=False) self.network, self.subnet = test_network.create_network(
image = cls.conn.compute.find_image(base.IMAGE_NAME, self.conn,
ignore_missing=False) self.NAME,
cls.network, cls.subnet = test_network.create_network(cls.conn, self.cidr)
cls.NAME, self.assertIsNotNone(self.network)
cls.cidr)
if not cls.network:
# We can't call TestCase.fail from within the setUpClass
# classmethod, but we need to raise some exception in order
# to get this setup to fail and thusly fail the entire class.
raise Exception("Unable to create network for TestServer")
sot = cls.conn.compute.create_server( sot = self.conn.compute.create_server(
name=cls.NAME, flavor_id=flavor.id, image_id=image.id, name=self.NAME, flavor_id=flavor.id, image_id=image.id,
networks=[{"uuid": cls.network.id}]) networks=[{"uuid": self.network.id}])
cls.conn.compute.wait_for_server(sot) self.conn.compute.wait_for_server(sot)
assert isinstance(sot, server.Server) assert isinstance(sot, server.Server)
cls.assertIs(cls.NAME, sot.name) self.assertEqual(self.NAME, sot.name)
cls.server = sot self.server = sot
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.compute.delete_server(self.server.id)
sot = cls.conn.compute.delete_server(cls.server.id) self.assertIsNone(sot)
cls.assertIs(None, sot)
# Need to wait for the stack to go away before network delete # Need to wait for the stack to go away before network delete
cls.conn.compute.wait_for_delete(cls.server) self.conn.compute.wait_for_delete(self.server)
cls.linger_for_delete() # TODO(shade) sleeping in tests is bad mmkay?
test_network.delete_network(cls.conn, cls.network, cls.subnet) time.sleep(40)
test_network.delete_network(self.conn, self.network, self.subnet)
super(TestServer, self).tearDown()
def test_find(self): def test_find(self):
sot = self.conn.compute.find_server(self.NAME) sot = self.conn.compute.find_server(self.NAME)

17
openstack/tests/functional/image/v2/test_image.py
View File

@@ -22,23 +22,20 @@ class TestImage(base.BaseFunctionalTest):
def __init__(self): def __init__(self):
self.image_api_version = '2' self.image_api_version = '2'
@classmethod def setUp(self):
def setUpClass(cls): super(TestImage, self).setUp()
opts = cls.ImageOpts() opts = self.ImageOpts()
cls.conn = connection.from_config(cloud_name=base.TEST_CLOUD, self.conn = connection.from_config(
options=opts) cloud_name=base.TEST_CLOUD, options=opts)
cls.img = cls.conn.image.upload_image( self.img = self.conn.image.upload_image(
name=TEST_IMAGE_NAME, name=TEST_IMAGE_NAME,
disk_format='raw', disk_format='raw',
container_format='bare', container_format='bare',
properties='{"description": "This is not an image"}', properties='{"description": "This is not an image"}',
data=open('CONTRIBUTING.rst', 'r') data=open('CONTRIBUTING.rst', 'r')
) )
self.addCleanup(self.conn.image.delete_image, self.img)
@classmethod
def tearDownClass(cls):
cls.conn.image.delete_image(cls.img)
def test_get_image(self): def test_get_image(self):
img2 = self.conn.image.get_image(self.img) img2 = self.conn.image.get_image(self.img)

9
openstack/tests/functional/load_balancer/base.py
View File

@@ -19,12 +19,7 @@ from openstack.tests.functional import base
class BaseLBFunctionalTest(base.BaseFunctionalTest): class BaseLBFunctionalTest(base.BaseFunctionalTest):
@classmethod def lb_wait_for_status(self, lb, status, failures, interval=1, wait=120):
def setUpClass(cls):
super(BaseLBFunctionalTest, cls).setUpClass()
@classmethod
def lb_wait_for_status(cls, lb, status, failures, interval=1, wait=120):
"""Wait for load balancer to be in a particular provisioning status. """Wait for load balancer to be in a particular provisioning status.
:param lb: The load balancer to wait on to reach the status. :param lb: The load balancer to wait on to reach the status.
@@ -49,7 +44,7 @@ class BaseLBFunctionalTest(base.BaseFunctionalTest):
failures = [] failures = []
while total_sleep < wait: while total_sleep < wait:
lb = cls.conn.load_balancer.get_load_balancer(lb.id) lb = self.conn.load_balancer.get_load_balancer(lb.id)
if lb.provisioning_status == status: if lb.provisioning_status == status:
return None return None
if lb.provisioning_status in failures: if lb.provisioning_status in failures:

186
openstack/tests/functional/load_balancer/v2/test_load_balancer.py
View File

@@ -10,9 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import unittest
import uuid
from openstack.load_balancer.v2 import health_monitor from openstack.load_balancer.v2 import health_monitor
from openstack.load_balancer.v2 import l7_policy from openstack.load_balancer.v2 import l7_policy
from openstack.load_balancer.v2 import l7_rule from openstack.load_balancer.v2 import l7_rule
@@ -20,21 +17,11 @@ from openstack.load_balancer.v2 import listener
from openstack.load_balancer.v2 import load_balancer from openstack.load_balancer.v2 import load_balancer
from openstack.load_balancer.v2 import member from openstack.load_balancer.v2 import member
from openstack.load_balancer.v2 import pool from openstack.load_balancer.v2 import pool
from openstack.tests.functional import base
from openstack.tests.functional.load_balancer import base as lb_base from openstack.tests.functional.load_balancer import base as lb_base
@unittest.skipUnless(base.service_exists(service_type='load-balancer'),
'Load-balancer service does not exist')
class TestLoadBalancer(lb_base.BaseLBFunctionalTest): class TestLoadBalancer(lb_base.BaseLBFunctionalTest):
HM_NAME = uuid.uuid4().hex
L7POLICY_NAME = uuid.uuid4().hex
LB_NAME = uuid.uuid4().hex
LISTENER_NAME = uuid.uuid4().hex
MEMBER_NAME = uuid.uuid4().hex
POOL_NAME = uuid.uuid4().hex
UPDATE_NAME = uuid.uuid4().hex
HM_ID = None HM_ID = None
L7POLICY_ID = None L7POLICY_ID = None
LB_ID = None LB_ID = None
@@ -58,110 +45,121 @@ class TestLoadBalancer(lb_base.BaseLBFunctionalTest):
L7RULE_TYPE = 'HOST_NAME' L7RULE_TYPE = 'HOST_NAME'
L7RULE_VALUE = 'example' L7RULE_VALUE = 'example'
# Note: Creating load balancers can be slow on some hosts due to nova # TODO(shade): Creating load balancers can be slow on some hosts due to
# instance boot times (up to ten minutes) so we are consolidating # nova instance boot times (up to ten minutes). This used to
# all of our functional tests here to reduce test runtime. # use setUpClass, but that's a whole other pile of bad, so
@classmethod # we may need to engineer something pleasing here.
def setUpClass(cls): def setUp(self):
super(TestLoadBalancer, cls).setUpClass() super(TestLoadBalancer, self).setUp()
subnets = list(cls.conn.network.subnets()) self.require_service('load-balancer')
cls.VIP_SUBNET_ID = subnets[0].id
cls.PROJECT_ID = cls.conn.session.get_project_id() self.HM_NAME = self.getUniqueString()
test_lb = cls.conn.load_balancer.create_load_balancer( self.L7POLICY_NAME = self.getUniqueString()
name=cls.LB_NAME, vip_subnet_id=cls.VIP_SUBNET_ID, self.LB_NAME = self.getUniqueString()
project_id=cls.PROJECT_ID) self.LISTENER_NAME = self.getUniqueString()
self.MEMBER_NAME = self.getUniqueString()
self.POOL_NAME = self.getUniqueString()
self.UPDATE_NAME = self.getUniqueString()
subnets = list(self.conn.network.subnets())
self.VIP_SUBNET_ID = subnets[0].id
self.PROJECT_ID = self.conn.session.get_project_id()
test_lb = self.conn.load_balancer.create_load_balancer(
name=self.LB_NAME, vip_subnet_id=self.VIP_SUBNET_ID,
project_id=self.PROJECT_ID)
assert isinstance(test_lb, load_balancer.LoadBalancer) assert isinstance(test_lb, load_balancer.LoadBalancer)
cls.assertIs(cls.LB_NAME, test_lb.name) self.assertEqual(self.LB_NAME, test_lb.name)
# Wait for the LB to go ACTIVE. On non-virtualization enabled hosts # Wait for the LB to go ACTIVE. On non-virtualization enabled hosts
# it can take nova up to ten minutes to boot a VM. # it can take nova up to ten minutes to boot a VM.
cls.lb_wait_for_status(test_lb, status='ACTIVE', self.lb_wait_for_status(test_lb, status='ACTIVE',
failures=['ERROR'], interval=1, wait=600) failures=['ERROR'], interval=1, wait=600)
cls.LB_ID = test_lb.id self.LB_ID = test_lb.id
test_listener = cls.conn.load_balancer.create_listener( test_listener = self.conn.load_balancer.create_listener(
name=cls.LISTENER_NAME, protocol=cls.PROTOCOL, name=self.LISTENER_NAME, protocol=self.PROTOCOL,
protocol_port=cls.PROTOCOL_PORT, loadbalancer_id=cls.LB_ID) protocol_port=self.PROTOCOL_PORT, loadbalancer_id=self.LB_ID)
assert isinstance(test_listener, listener.Listener) assert isinstance(test_listener, listener.Listener)
cls.assertIs(cls.LISTENER_NAME, test_listener.name) self.assertEqual(self.LISTENER_NAME, test_listener.name)
cls.LISTENER_ID = test_listener.id self.LISTENER_ID = test_listener.id
cls.lb_wait_for_status(test_lb, status='ACTIVE', self.lb_wait_for_status(test_lb, status='ACTIVE',
failures=['ERROR']) failures=['ERROR'])
test_pool = cls.conn.load_balancer.create_pool( test_pool = self.conn.load_balancer.create_pool(
name=cls.POOL_NAME, protocol=cls.PROTOCOL, name=self.POOL_NAME, protocol=self.PROTOCOL,
lb_algorithm=cls.LB_ALGORITHM, listener_id=cls.LISTENER_ID) lb_algorithm=self.LB_ALGORITHM, listener_id=self.LISTENER_ID)
assert isinstance(test_pool, pool.Pool) assert isinstance(test_pool, pool.Pool)
cls.assertIs(cls.POOL_NAME, test_pool.name) self.assertEqual(self.POOL_NAME, test_pool.name)
cls.POOL_ID = test_pool.id self.POOL_ID = test_pool.id
cls.lb_wait_for_status(test_lb, status='ACTIVE', self.lb_wait_for_status(test_lb, status='ACTIVE',
failures=['ERROR']) failures=['ERROR'])
test_member = cls.conn.load_balancer.create_member( test_member = self.conn.load_balancer.create_member(
pool=cls.POOL_ID, name=cls.MEMBER_NAME, address=cls.MEMBER_ADDRESS, pool=self.POOL_ID, name=self.MEMBER_NAME,
protocol_port=cls.PROTOCOL_PORT, weight=cls.WEIGHT) address=self.MEMBER_ADDRESS,
protocol_port=self.PROTOCOL_PORT, weight=self.WEIGHT)
assert isinstance(test_member, member.Member) assert isinstance(test_member, member.Member)
cls.assertIs(cls.MEMBER_NAME, test_member.name) self.assertEqual(self.MEMBER_NAME, test_member.name)
cls.MEMBER_ID = test_member.id self.MEMBER_ID = test_member.id
cls.lb_wait_for_status(test_lb, status='ACTIVE', self.lb_wait_for_status(test_lb, status='ACTIVE',
failures=['ERROR']) failures=['ERROR'])
test_hm = cls.conn.load_balancer.create_health_monitor( test_hm = self.conn.load_balancer.create_health_monitor(
pool_id=cls.POOL_ID, name=cls.HM_NAME, delay=cls.DELAY, pool_id=self.POOL_ID, name=self.HM_NAME, delay=self.DELAY,
timeout=cls.TIMEOUT, max_retries=cls.MAX_RETRY, type=cls.HM_TYPE) timeout=self.TIMEOUT, max_retries=self.MAX_RETRY,
type=self.HM_TYPE)
assert isinstance(test_hm, health_monitor.HealthMonitor) assert isinstance(test_hm, health_monitor.HealthMonitor)
cls.assertIs(cls.HM_NAME, test_hm.name) self.assertEqual(self.HM_NAME, test_hm.name)
cls.HM_ID = test_hm.id self.HM_ID = test_hm.id
cls.lb_wait_for_status(test_lb, status='ACTIVE', self.lb_wait_for_status(test_lb, status='ACTIVE',
failures=['ERROR']) failures=['ERROR'])
test_l7policy = cls.conn.load_balancer.create_l7_policy( test_l7policy = self.conn.load_balancer.create_l7_policy(
listener_id=cls.LISTENER_ID, name=cls.L7POLICY_NAME, listener_id=self.LISTENER_ID, name=self.L7POLICY_NAME,
action=cls.ACTION, redirect_url=cls.REDIRECT_URL) action=self.ACTION, redirect_url=self.REDIRECT_URL)
assert isinstance(test_l7policy, l7_policy.L7Policy) assert isinstance(test_l7policy, l7_policy.L7Policy)
cls.assertIs(cls.L7POLICY_NAME, test_l7policy.name) self.assertEqual(self.L7POLICY_NAME, test_l7policy.name)
cls.L7POLICY_ID = test_l7policy.id self.L7POLICY_ID = test_l7policy.id
cls.lb_wait_for_status(test_lb, status='ACTIVE', self.lb_wait_for_status(test_lb, status='ACTIVE',
failures=['ERROR']) failures=['ERROR'])
test_l7rule = cls.conn.load_balancer.create_l7_rule( test_l7rule = self.conn.load_balancer.create_l7_rule(
l7_policy=cls.L7POLICY_ID, compare_type=cls.COMPARE_TYPE, l7_policy=self.L7POLICY_ID, compare_type=self.COMPARE_TYPE,
type=cls.L7RULE_TYPE, value=cls.L7RULE_VALUE) type=self.L7RULE_TYPE, value=self.L7RULE_VALUE)
assert isinstance(test_l7rule, l7_rule.L7Rule) assert isinstance(test_l7rule, l7_rule.L7Rule)
cls.assertIs(cls.COMPARE_TYPE, test_l7rule.compare_type) self.assertEqual(self.COMPARE_TYPE, test_l7rule.compare_type)
cls.L7RULE_ID = test_l7rule.id self.L7RULE_ID = test_l7rule.id
cls.lb_wait_for_status(test_lb, status='ACTIVE', self.lb_wait_for_status(test_lb, status='ACTIVE',
failures=['ERROR']) failures=['ERROR'])
@classmethod def tearDown(self):
def tearDownClass(cls): test_lb = self.conn.load_balancer.get_load_balancer(self.LB_ID)
test_lb = cls.conn.load_balancer.get_load_balancer(cls.LB_ID) self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
cls.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
cls.conn.load_balancer.delete_l7_rule( self.conn.load_balancer.delete_l7_rule(
cls.L7RULE_ID, l7_policy=cls.L7POLICY_ID, ignore_missing=False) self.L7RULE_ID, l7_policy=self.L7POLICY_ID, ignore_missing=False)
cls.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR']) self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
cls.conn.load_balancer.delete_l7_policy( self.conn.load_balancer.delete_l7_policy(
cls.L7POLICY_ID, ignore_missing=False) self.L7POLICY_ID, ignore_missing=False)
cls.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR']) self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
cls.conn.load_balancer.delete_health_monitor( self.conn.load_balancer.delete_health_monitor(
cls.HM_ID, ignore_missing=False) self.HM_ID, ignore_missing=False)
cls.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR']) self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
cls.conn.load_balancer.delete_member( self.conn.load_balancer.delete_member(
cls.MEMBER_ID, cls.POOL_ID, ignore_missing=False) self.MEMBER_ID, self.POOL_ID, ignore_missing=False)
cls.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR']) self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
cls.conn.load_balancer.delete_pool(cls.POOL_ID, ignore_missing=False) self.conn.load_balancer.delete_pool(self.POOL_ID, ignore_missing=False)
cls.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR']) self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
cls.conn.load_balancer.delete_listener(cls.LISTENER_ID, self.conn.load_balancer.delete_listener(self.LISTENER_ID,
ignore_missing=False) ignore_missing=False)
cls.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR']) self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
cls.conn.load_balancer.delete_load_balancer( self.conn.load_balancer.delete_load_balancer(
cls.LB_ID, ignore_missing=False) self.LB_ID, ignore_missing=False)
super(TestLoadBalancer, self).tearDown()
def test_lb_find(self): def test_lb_find(self):
test_lb = self.conn.load_balancer.find_load_balancer(self.LB_NAME) test_lb = self.conn.load_balancer.find_load_balancer(self.LB_NAME)

30
openstack/tests/functional/network/v2/test_address_scope.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import address_scope as _address_scope from openstack.network.v2 import address_scope as _address_scope
from openstack.tests.functional import base from openstack.tests.functional import base
@@ -19,27 +18,26 @@ from openstack.tests.functional import base
class TestAddressScope(base.BaseFunctionalTest): class TestAddressScope(base.BaseFunctionalTest):
ADDRESS_SCOPE_ID = None ADDRESS_SCOPE_ID = None
ADDRESS_SCOPE_NAME = uuid.uuid4().hex
ADDRESS_SCOPE_NAME_UPDATED = uuid.uuid4().hex
IS_SHARED = False IS_SHARED = False
IP_VERSION = 4 IP_VERSION = 4
@classmethod def setUp(self):
def setUpClass(cls): super(TestAddressScope, self).setUp()
super(TestAddressScope, cls).setUpClass() self.ADDRESS_SCOPE_NAME = self.getUniqueString()
address_scope = cls.conn.network.create_address_scope( self.ADDRESS_SCOPE_NAME_UPDATED = self.getUniqueString()
ip_version=cls.IP_VERSION, address_scope = self.conn.network.create_address_scope(
name=cls.ADDRESS_SCOPE_NAME, ip_version=self.IP_VERSION,
shared=cls.IS_SHARED, name=self.ADDRESS_SCOPE_NAME,
shared=self.IS_SHARED,
) )
assert isinstance(address_scope, _address_scope.AddressScope) assert isinstance(address_scope, _address_scope.AddressScope)
cls.assertIs(cls.ADDRESS_SCOPE_NAME, address_scope.name) self.assertEqual(self.ADDRESS_SCOPE_NAME, address_scope.name)
cls.ADDRESS_SCOPE_ID = address_scope.id self.ADDRESS_SCOPE_ID = address_scope.id
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.network.delete_address_scope(self.ADDRESS_SCOPE_ID)
sot = cls.conn.network.delete_address_scope(cls.ADDRESS_SCOPE_ID) self.assertIsNone(sot)
cls.assertIs(None, sot) super(TestAddressScope, self).tearDown()
def test_find(self): def test_find(self):
sot = self.conn.network.find_address_scope(self.ADDRESS_SCOPE_NAME) sot = self.conn.network.find_address_scope(self.ADDRESS_SCOPE_NAME)

11
openstack/tests/functional/network/v2/test_agent.py
View File

@@ -28,12 +28,11 @@ class TestAgent(base.BaseFunctionalTest):
return False return False
return True return True
@classmethod def setUp(self):
def setUpClass(cls): super(TestAgent, self).setUp()
super(TestAgent, cls).setUpClass() agent_list = list(self.conn.network.agents())
agent_list = list(cls.conn.network.agents()) self.AGENT = agent_list[0]
cls.AGENT = agent_list[0] assert isinstance(self.AGENT, agent.Agent)
assert isinstance(cls.AGENT, agent.Agent)
def test_list(self): def test_list(self):
agent_list = list(self.conn.network.agents()) agent_list = list(self.conn.network.agents())

26
openstack/tests/functional/network/v2/test_agent_add_remove_network.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import network from openstack.network.v2 import network
from openstack.tests.functional import base from openstack.tests.functional import base
@@ -18,34 +17,29 @@ from openstack.tests.functional import base
class TestAgentNetworks(base.BaseFunctionalTest): class TestAgentNetworks(base.BaseFunctionalTest):
NETWORK_NAME = 'network-' + uuid.uuid4().hex
NETWORK_ID = None NETWORK_ID = None
AGENT = None AGENT = None
AGENT_ID = None AGENT_ID = None
@classmethod def setUp(self):
def setUpClass(cls): super(TestAgentNetworks, self).setUp()
super(TestAgentNetworks, cls).setUpClass()
net = cls.conn.network.create_network(name=cls.NETWORK_NAME) self.NETWORK_NAME = self.getUniqueString('network')
net = self.conn.network.create_network(name=self.NETWORK_NAME)
self.addCleanup(self.conn.network.delete_network, net.id)
assert isinstance(net, network.Network) assert isinstance(net, network.Network)
cls.NETWORK_ID = net.id self.NETWORK_ID = net.id
agent_list = list(cls.conn.network.agents()) agent_list = list(self.conn.network.agents())
agents = [agent for agent in agent_list agents = [agent for agent in agent_list
if agent.agent_type == 'DHCP agent'] if agent.agent_type == 'DHCP agent']
cls.AGENT = agents[0] self.AGENT = agents[0]
cls.AGENT_ID = cls.AGENT.id self.AGENT_ID = self.AGENT.id
@classmethod def test_add_remove_agent(self):
def tearDownClass(cls):
cls.conn.network.delete_network(cls.NETWORK_ID)
def test_add_agent_to_network(self):
net = self.AGENT.add_agent_to_network(self.conn.session, net = self.AGENT.add_agent_to_network(self.conn.session,
network_id=self.NETWORK_ID) network_id=self.NETWORK_ID)
self._verify_add(net) self._verify_add(net)
def test_remove_agent_from_network(self):
net = self.AGENT.remove_agent_from_network(self.conn.session, net = self.AGENT.remove_agent_from_network(self.conn.session,
network_id=self.NETWORK_ID) network_id=self.NETWORK_ID)
self._verify_remove(net) self._verify_remove(net)

21
openstack/tests/functional/network/v2/test_agent_add_remove_router.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import router from openstack.network.v2 import router
from openstack.tests.functional import base from openstack.tests.functional import base
@@ -18,24 +17,20 @@ from openstack.tests.functional import base
class TestAgentRouters(base.BaseFunctionalTest): class TestAgentRouters(base.BaseFunctionalTest):
ROUTER_NAME = 'router-name-' + uuid.uuid4().hex
ROUTER = None ROUTER = None
AGENT = None AGENT = None
@classmethod def setUp(self):
def setUpClass(cls): super(TestAgentRouters, self).setUp()
super(TestAgentRouters, cls).setUpClass()
cls.ROUTER = cls.conn.network.create_router(name=cls.ROUTER_NAME) self.ROUTER_NAME = 'router-name-' + self.getUniqueString('router-name')
assert isinstance(cls.ROUTER, router.Router) self.ROUTER = self.conn.network.create_router(name=self.ROUTER_NAME)
agent_list = list(cls.conn.network.agents()) self.addCleanup(self.conn.network.delete_router, self.ROUTER)
assert isinstance(self.ROUTER, router.Router)
agent_list = list(self.conn.network.agents())
agents = [agent for agent in agent_list agents = [agent for agent in agent_list
if agent.agent_type == 'L3 agent'] if agent.agent_type == 'L3 agent']
cls.AGENT = agents[0] self.AGENT = agents[0]
@classmethod
def tearDownClass(cls):
cls.conn.network.delete_router(cls.ROUTER)
def test_add_router_to_agent(self): def test_add_router_to_agent(self):
self.conn.network.add_router_to_agent(self.AGENT, self.ROUTER) self.conn.network.add_router_to_agent(self.AGENT, self.ROUTER)

17
openstack/tests/functional/network/v2/test_auto_allocated_topology.py
View File

@@ -19,16 +19,15 @@ class TestAutoAllocatedTopology(base.BaseFunctionalTest):
NETWORK_ID = None NETWORK_ID = None
PROJECT_ID = None PROJECT_ID = None
@classmethod def setUp(self):
def setUpClass(cls): super(TestAutoAllocatedTopology, self).setUp()
super(TestAutoAllocatedTopology, cls).setUpClass() projects = [o.project_id for o in self.conn.network.networks()]
projects = [o.project_id for o in cls.conn.network.networks()] self.PROJECT_ID = projects[0]
cls.PROJECT_ID = projects[0]
@classmethod def tearDown(self):
def tearDownClass(cls): res = self.conn.network.delete_auto_allocated_topology(self.PROJECT_ID)
res = cls.conn.network.delete_auto_allocated_topology(cls.PROJECT_ID) self.assertIsNone(res)
cls.assertIs(None, res) super(TestAutoAllocatedTopology, self).tearDown()
def test_dry_run_option_pass(self): def test_dry_run_option_pass(self):
# Dry run will only pass if there is a public network # Dry run will only pass if there is a public network

24
openstack/tests/functional/network/v2/test_dvr_router.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import router from openstack.network.v2 import router
from openstack.tests.functional import base from openstack.tests.functional import base
@@ -18,22 +17,21 @@ from openstack.tests.functional import base
class TestDVRRouter(base.BaseFunctionalTest): class TestDVRRouter(base.BaseFunctionalTest):
NAME = uuid.uuid4().hex
UPDATE_NAME = uuid.uuid4().hex
ID = None ID = None
@classmethod def setUp(self):
def setUpClass(cls): super(TestDVRRouter, self).setUp()
super(TestDVRRouter, cls).setUpClass() self.NAME = self.getUniqueString()
sot = cls.conn.network.create_router(name=cls.NAME, distributed=True) self.UPDATE_NAME = self.getUniqueString()
sot = self.conn.network.create_router(name=self.NAME, distributed=True)
assert isinstance(sot, router.Router) assert isinstance(sot, router.Router)
cls.assertIs(cls.NAME, sot.name) self.assertEqual(self.NAME, sot.name)
cls.ID = sot.id self.ID = sot.id
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.network.delete_router(self.ID, ignore_missing=False)
sot = cls.conn.network.delete_router(cls.ID, ignore_missing=False) self.assertIsNone(sot)
cls.assertIs(None, sot) super(TestDVRRouter, self).tearDown()
def test_find(self): def test_find(self):
sot = self.conn.network.find_router(self.NAME) sot = self.conn.network.find_router(self.NAME)

43
openstack/tests/functional/network/v2/test_flavor.py
View File

@@ -10,15 +10,12 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import flavor from openstack.network.v2 import flavor
from openstack.tests.functional import base from openstack.tests.functional import base
class TestFlavor(base.BaseFunctionalTest): class TestFlavor(base.BaseFunctionalTest):
FLAVOR_NAME = uuid.uuid4().hex
UPDATE_NAME = "UPDATED-NAME" UPDATE_NAME = "UPDATED-NAME"
SERVICE_TYPE = "FLAVORS" SERVICE_TYPE = "FLAVORS"
ID = None ID = None
@@ -26,29 +23,30 @@ class TestFlavor(base.BaseFunctionalTest):
SERVICE_PROFILE_DESCRIPTION = "DESCRIPTION" SERVICE_PROFILE_DESCRIPTION = "DESCRIPTION"
METAINFO = "FlAVOR_PROFILE_METAINFO" METAINFO = "FlAVOR_PROFILE_METAINFO"
@classmethod def setUp(self):
def setUpClass(cls): super(TestFlavor, self).setUp()
super(TestFlavor, cls).setUpClass() self.FLAVOR_NAME = self.getUniqueString('flavor')
flavors = cls.conn.network.create_flavor(name=cls.FLAVOR_NAME, flavors = self.conn.network.create_flavor(
service_type=cls.SERVICE_TYPE) name=self.FLAVOR_NAME,
service_type=self.SERVICE_TYPE)
assert isinstance(flavors, flavor.Flavor) assert isinstance(flavors, flavor.Flavor)
cls.assertIs(cls.FLAVOR_NAME, flavors.name) self.assertEqual(self.FLAVOR_NAME, flavors.name)
cls.assertIs(cls.SERVICE_TYPE, flavors.service_type) self.assertEqual(self.SERVICE_TYPE, flavors.service_type)
cls.ID = flavors.id self.ID = flavors.id
cls.service_profiles = cls.conn.network.create_service_profile( self.service_profiles = self.conn.network.create_service_profile(
description=cls.SERVICE_PROFILE_DESCRIPTION, description=self.SERVICE_PROFILE_DESCRIPTION,
metainfo=cls.METAINFO,) metainfo=self.METAINFO,)
@classmethod def tearDown(self):
def tearDownClass(cls): flavors = self.conn.network.delete_flavor(self.ID, ignore_missing=True)
flavors = cls.conn.network.delete_flavor(cls.ID, ignore_missing=True) self.assertIsNone(flavors)
cls.assertIs(None, flavors)
service_profiles = cls.conn.network.delete_service_profile( service_profiles = self.conn.network.delete_service_profile(
cls.ID, ignore_missing=True) self.ID, ignore_missing=True)
cls.assertIs(None, service_profiles) self.assertIsNone(service_profiles)
super(TestFlavor, self).tearDown()
def test_find(self): def test_find(self):
flavors = self.conn.network.find_flavor(self.FLAVOR_NAME) flavors = self.conn.network.find_flavor(self.FLAVOR_NAME)
@@ -68,13 +66,12 @@ class TestFlavor(base.BaseFunctionalTest):
name=self.UPDATE_NAME) name=self.UPDATE_NAME)
self.assertEqual(self.UPDATE_NAME, flavor.name) self.assertEqual(self.UPDATE_NAME, flavor.name)
def test_associate_flavor_with_service_profile(self): def test_associate_disassociate_flavor_with_service_profile(self):
response = \ response = \
self.conn.network.associate_flavor_with_service_profile( self.conn.network.associate_flavor_with_service_profile(
self.ID, self.service_profiles.id) self.ID, self.service_profiles.id)
self.assertIsNotNone(response) self.assertIsNotNone(response)
def test_disassociate_flavor_from_service_profile(self):
response = \ response = \
self.conn.network.disassociate_flavor_from_service_profile( self.conn.network.disassociate_flavor_from_service_profile(
self.ID, self.service_profiles.id) self.ID, self.service_profiles.id)

135
openstack/tests/functional/network/v2/test_floating_ip.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import floating_ip from openstack.network.v2 import floating_ip
from openstack.network.v2 import network from openstack.network.v2 import network
@@ -22,11 +21,6 @@ from openstack.tests.functional import base
class TestFloatingIP(base.BaseFunctionalTest): class TestFloatingIP(base.BaseFunctionalTest):
ROT_NAME = uuid.uuid4().hex
EXT_NET_NAME = uuid.uuid4().hex
EXT_SUB_NAME = uuid.uuid4().hex
INT_NET_NAME = uuid.uuid4().hex
INT_SUB_NAME = uuid.uuid4().hex
IPV4 = 4 IPV4 = 4
EXT_CIDR = "10.100.0.0/24" EXT_CIDR = "10.100.0.0/24"
INT_CIDR = "10.101.0.0/24" INT_CIDR = "10.101.0.0/24"
@@ -38,84 +32,89 @@ class TestFloatingIP(base.BaseFunctionalTest):
PORT_ID = None PORT_ID = None
FIP = None FIP = None
@classmethod def setUp(self):
def setUpClass(cls): super(TestFloatingIP, self).setUp()
super(TestFloatingIP, cls).setUpClass() self.ROT_NAME = self.getUniqueString()
self.EXT_NET_NAME = self.getUniqueString()
self.EXT_SUB_NAME = self.getUniqueString()
self.INT_NET_NAME = self.getUniqueString()
self.INT_SUB_NAME = self.getUniqueString()
# Create Exeternal Network # Create Exeternal Network
args = {'router:external': True} args = {'router:external': True}
net = cls._create_network(cls.EXT_NET_NAME, **args) net = self._create_network(self.EXT_NET_NAME, **args)
cls.EXT_NET_ID = net.id self.EXT_NET_ID = net.id
sub = cls._create_subnet(cls.EXT_SUB_NAME, cls.EXT_NET_ID, sub = self._create_subnet(
cls.EXT_CIDR) self.EXT_SUB_NAME, self.EXT_NET_ID, self.EXT_CIDR)
cls.EXT_SUB_ID = sub.id self.EXT_SUB_ID = sub.id
# Create Internal Network # Create Internal Network
net = cls._create_network(cls.INT_NET_NAME) net = self._create_network(self.INT_NET_NAME)
cls.INT_NET_ID = net.id self.INT_NET_ID = net.id
sub = cls._create_subnet(cls.INT_SUB_NAME, cls.INT_NET_ID, sub = self._create_subnet(
cls.INT_CIDR) self.INT_SUB_NAME, self.INT_NET_ID, self.INT_CIDR)
cls.INT_SUB_ID = sub.id self.INT_SUB_ID = sub.id
# Create Router # Create Router
args = {'external_gateway_info': {'network_id': cls.EXT_NET_ID}} args = {'external_gateway_info': {'network_id': self.EXT_NET_ID}}
sot = cls.conn.network.create_router(name=cls.ROT_NAME, **args) sot = self.conn.network.create_router(name=self.ROT_NAME, **args)
assert isinstance(sot, router.Router) assert isinstance(sot, router.Router)
cls.assertIs(cls.ROT_NAME, sot.name) self.assertEqual(self.ROT_NAME, sot.name)
cls.ROT_ID = sot.id self.ROT_ID = sot.id
cls.ROT = sot self.ROT = sot
# Add Router's Interface to Internal Network # Add Router's Interface to Internal Network
sot = cls.ROT.add_interface(cls.conn.session, subnet_id=cls.INT_SUB_ID) sot = self.ROT.add_interface(
cls.assertIs(sot['subnet_id'], cls.INT_SUB_ID) self.conn.session, subnet_id=self.INT_SUB_ID)
self.assertEqual(sot['subnet_id'], self.INT_SUB_ID)
# Create Port in Internal Network # Create Port in Internal Network
prt = cls.conn.network.create_port(network_id=cls.INT_NET_ID) prt = self.conn.network.create_port(network_id=self.INT_NET_ID)
assert isinstance(prt, port.Port) assert isinstance(prt, port.Port)
cls.PORT_ID = prt.id self.PORT_ID = prt.id
# Create Floating IP. # Create Floating IP.
fip = cls.conn.network.create_ip(floating_network_id=cls.EXT_NET_ID) fip = self.conn.network.create_ip(floating_network_id=self.EXT_NET_ID)
assert isinstance(fip, floating_ip.FloatingIP) assert isinstance(fip, floating_ip.FloatingIP)
cls.FIP = fip self.FIP = fip
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.network.delete_ip(self.FIP.id, ignore_missing=False)
sot = cls.conn.network.delete_ip(cls.FIP.id, ignore_missing=False) self.assertIsNone(sot)
cls.assertIs(None, sot) sot = self.conn.network.delete_port(self.PORT_ID, ignore_missing=False)
sot = cls.conn.network.delete_port(cls.PORT_ID, ignore_missing=False) self.assertIsNone(sot)
cls.assertIs(None, sot) sot = self.ROT.remove_interface(
sot = cls.ROT.remove_interface(cls.conn.session, self.conn.session, subnet_id=self.INT_SUB_ID)
subnet_id=cls.INT_SUB_ID) self.assertEqual(sot['subnet_id'], self.INT_SUB_ID)
cls.assertIs(sot['subnet_id'], cls.INT_SUB_ID) sot = self.conn.network.delete_router(
sot = cls.conn.network.delete_router(cls.ROT_ID, ignore_missing=False) self.ROT_ID, ignore_missing=False)
cls.assertIs(None, sot) self.assertIsNone(sot)
sot = cls.conn.network.delete_subnet(cls.EXT_SUB_ID, sot = self.conn.network.delete_subnet(
ignore_missing=False) self.EXT_SUB_ID, ignore_missing=False)
cls.assertIs(None, sot) self.assertIsNone(sot)
sot = cls.conn.network.delete_network(cls.EXT_NET_ID, sot = self.conn.network.delete_network(
ignore_missing=False) self.EXT_NET_ID, ignore_missing=False)
cls.assertIs(None, sot) self.assertIsNone(sot)
sot = cls.conn.network.delete_subnet(cls.INT_SUB_ID, sot = self.conn.network.delete_subnet(
ignore_missing=False) self.INT_SUB_ID, ignore_missing=False)
cls.assertIs(None, sot) self.assertIsNone(sot)
sot = cls.conn.network.delete_network(cls.INT_NET_ID, sot = self.conn.network.delete_network(
ignore_missing=False) self.INT_NET_ID, ignore_missing=False)
cls.assertIs(None, sot) self.assertIsNone(sot)
super(TestFloatingIP, self).tearDown()
@classmethod def _create_network(self, name, **args):
def _create_network(cls, name, **args): self.name = name
cls.name = name net = self.conn.network.create_network(name=name, **args)
net = cls.conn.network.create_network(name=name, **args)
assert isinstance(net, network.Network) assert isinstance(net, network.Network)
cls.assertIs(cls.name, net.name) self.assertEqual(self.name, net.name)
return net return net
@classmethod def _create_subnet(self, name, net_id, cidr):
def _create_subnet(cls, name, net_id, cidr): self.name = name
cls.name = name self.net_id = net_id
cls.net_id = net_id self.cidr = cidr
cls.cidr = cidr sub = self.conn.network.create_subnet(
sub = cls.conn.network.create_subnet(name=cls.name, name=self.name,
ip_version=cls.IPV4, ip_version=self.IPV4,
network_id=cls.net_id, network_id=self.net_id,
cidr=cls.cidr) cidr=self.cidr)
assert isinstance(sub, subnet.Subnet) assert isinstance(sub, subnet.Subnet)
cls.assertIs(cls.name, sub.name) self.assertEqual(self.name, sub.name)
return sub return sub
def test_find_by_id(self): def test_find_by_id(self):

22
openstack/tests/functional/network/v2/test_network.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import network from openstack.network.v2 import network
from openstack.tests.functional import base from openstack.tests.functional import base
@@ -40,21 +39,20 @@ def delete_network(conn, network, subnet):
class TestNetwork(base.BaseFunctionalTest): class TestNetwork(base.BaseFunctionalTest):
NAME = uuid.uuid4().hex
ID = None ID = None
@classmethod def setUp(self):
def setUpClass(cls): super(TestNetwork, self).setUp()
super(TestNetwork, cls).setUpClass() self.NAME = self.getUniqueString()
sot = cls.conn.network.create_network(name=cls.NAME) sot = self.conn.network.create_network(name=self.NAME)
assert isinstance(sot, network.Network) assert isinstance(sot, network.Network)
cls.assertIs(cls.NAME, sot.name) self.assertEqual(self.NAME, sot.name)
cls.ID = sot.id self.ID = sot.id
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.network.delete_network(self.ID, ignore_missing=False)
sot = cls.conn.network.delete_network(cls.ID, ignore_missing=False) self.assertIsNone(sot)
cls.assertIs(None, sot) super(TestNetwork, self).tearDown()
def test_find(self): def test_find(self):
sot = self.conn.network.find_network(self.NAME) sot = self.conn.network.find_network(self.NAME)

58
openstack/tests/functional/network/v2/test_network_ip_availability.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import network from openstack.network.v2 import network
from openstack.network.v2 import port from openstack.network.v2 import port
@@ -20,44 +19,45 @@ from openstack.tests.functional import base
class TestNetworkIPAvailability(base.BaseFunctionalTest): class TestNetworkIPAvailability(base.BaseFunctionalTest):
NET_NAME = uuid.uuid4().hex
SUB_NAME = uuid.uuid4().hex
PORT_NAME = uuid.uuid4().hex
UPDATE_NAME = uuid.uuid4().hex
IPV4 = 4 IPV4 = 4
CIDR = "10.100.0.0/24" CIDR = "10.100.0.0/24"
NET_ID = None NET_ID = None
SUB_ID = None SUB_ID = None
PORT_ID = None PORT_ID = None
@classmethod def setUp(self):
def setUpClass(cls): super(TestNetworkIPAvailability, self).setUp()
super(TestNetworkIPAvailability, cls).setUpClass() self.NET_NAME = self.getUniqueString()
net = cls.conn.network.create_network(name=cls.NET_NAME) self.SUB_NAME = self.getUniqueString()
self.PORT_NAME = self.getUniqueString()
self.UPDATE_NAME = self.getUniqueString()
net = self.conn.network.create_network(name=self.NET_NAME)
assert isinstance(net, network.Network) assert isinstance(net, network.Network)
cls.assertIs(cls.NET_NAME, net.name) self.assertEqual(self.NET_NAME, net.name)
cls.NET_ID = net.id self.NET_ID = net.id
sub = cls.conn.network.create_subnet(name=cls.SUB_NAME, sub = self.conn.network.create_subnet(
ip_version=cls.IPV4, name=self.SUB_NAME,
network_id=cls.NET_ID, ip_version=self.IPV4,
cidr=cls.CIDR) network_id=self.NET_ID,
cidr=self.CIDR)
assert isinstance(sub, subnet.Subnet) assert isinstance(sub, subnet.Subnet)
cls.assertIs(cls.SUB_NAME, sub.name) self.assertEqual(self.SUB_NAME, sub.name)
cls.SUB_ID = sub.id self.SUB_ID = sub.id
prt = cls.conn.network.create_port(name=cls.PORT_NAME, prt = self.conn.network.create_port(
network_id=cls.NET_ID) name=self.PORT_NAME,
network_id=self.NET_ID)
assert isinstance(prt, port.Port) assert isinstance(prt, port.Port)
cls.assertIs(cls.PORT_NAME, prt.name) self.assertEqual(self.PORT_NAME, prt.name)
cls.PORT_ID = prt.id self.PORT_ID = prt.id
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.network.delete_port(self.PORT_ID)
sot = cls.conn.network.delete_port(cls.PORT_ID) self.assertIsNone(sot)
cls.assertIs(None, sot) sot = self.conn.network.delete_subnet(self.SUB_ID)
sot = cls.conn.network.delete_subnet(cls.SUB_ID) self.assertIsNone(sot)
cls.assertIs(None, sot) sot = self.conn.network.delete_network(self.NET_ID)
sot = cls.conn.network.delete_network(cls.NET_ID) self.assertIsNone(sot)
cls.assertIs(None, sot) super(TestNetworkIPAvailability, self).tearDown()
def test_find(self): def test_find(self):
sot = self.conn.network.find_network_ip_availability(self.NET_ID) sot = self.conn.network.find_network_ip_availability(self.NET_ID)

61
openstack/tests/functional/network/v2/test_port.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import network from openstack.network.v2 import network
from openstack.network.v2 import port from openstack.network.v2 import port
@@ -20,44 +19,48 @@ from openstack.tests.functional import base
class TestPort(base.BaseFunctionalTest): class TestPort(base.BaseFunctionalTest):
NET_NAME = uuid.uuid4().hex
SUB_NAME = uuid.uuid4().hex
PORT_NAME = uuid.uuid4().hex
UPDATE_NAME = uuid.uuid4().hex
IPV4 = 4 IPV4 = 4
CIDR = "10.100.0.0/24" CIDR = "10.100.0.0/24"
NET_ID = None NET_ID = None
SUB_ID = None SUB_ID = None
PORT_ID = None PORT_ID = None
@classmethod def setUp(self):
def setUpClass(cls): super(TestPort, self).setUp()
super(TestPort, cls).setUpClass() self.NET_NAME = self.getUniqueString()
net = cls.conn.network.create_network(name=cls.NET_NAME) self.SUB_NAME = self.getUniqueString()
self.PORT_NAME = self.getUniqueString()
self.UPDATE_NAME = self.getUniqueString()
net = self.conn.network.create_network(name=self.NET_NAME)
assert isinstance(net, network.Network) assert isinstance(net, network.Network)
cls.assertIs(cls.NET_NAME, net.name) self.assertEqual(self.NET_NAME, net.name)
cls.NET_ID = net.id self.NET_ID = net.id
sub = cls.conn.network.create_subnet(name=cls.SUB_NAME, sub = self.conn.network.create_subnet(
ip_version=cls.IPV4, name=self.SUB_NAME,
network_id=cls.NET_ID, ip_version=self.IPV4,
cidr=cls.CIDR) network_id=self.NET_ID,
cidr=self.CIDR)
assert isinstance(sub, subnet.Subnet) assert isinstance(sub, subnet.Subnet)
cls.assertIs(cls.SUB_NAME, sub.name) self.assertEqual(self.SUB_NAME, sub.name)
cls.SUB_ID = sub.id self.SUB_ID = sub.id
prt = cls.conn.network.create_port(name=cls.PORT_NAME, prt = self.conn.network.create_port(
network_id=cls.NET_ID) name=self.PORT_NAME,
network_id=self.NET_ID)
assert isinstance(prt, port.Port) assert isinstance(prt, port.Port)
cls.assertIs(cls.PORT_NAME, prt.name) self.assertEqual(self.PORT_NAME, prt.name)
cls.PORT_ID = prt.id self.PORT_ID = prt.id
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.network.delete_port(
sot = cls.conn.network.delete_port(cls.PORT_ID, ignore_missing=False) self.PORT_ID, ignore_missing=False)
cls.assertIs(None, sot) self.assertIsNone(sot)
sot = cls.conn.network.delete_subnet(cls.SUB_ID, ignore_missing=False) sot = self.conn.network.delete_subnet(
cls.assertIs(None, sot) self.SUB_ID, ignore_missing=False)
sot = cls.conn.network.delete_network(cls.NET_ID, ignore_missing=False) self.assertIsNone(sot)
cls.assertIs(None, sot) sot = self.conn.network.delete_network(
self.NET_ID, ignore_missing=False)
self.assertIsNone(sot)
super(TestPort, self).tearDown()
def test_find(self): def test_find(self):
sot = self.conn.network.find_port(self.PORT_NAME) sot = self.conn.network.find_port(self.PORT_NAME)

52
openstack/tests/functional/network/v2/test_qos_bandwidth_limit_rule.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import (qos_bandwidth_limit_rule as from openstack.network.v2 import (qos_bandwidth_limit_rule as
_qos_bandwidth_limit_rule) _qos_bandwidth_limit_rule)
@@ -20,10 +19,8 @@ from openstack.tests.functional import base
class TestQoSBandwidthLimitRule(base.BaseFunctionalTest): class TestQoSBandwidthLimitRule(base.BaseFunctionalTest):
QOS_POLICY_ID = None QOS_POLICY_ID = None
QOS_POLICY_NAME = uuid.uuid4().hex
QOS_IS_SHARED = False QOS_IS_SHARED = False
QOS_POLICY_DESCRIPTION = "QoS policy description" QOS_POLICY_DESCRIPTION = "QoS policy description"
RULE_ID = uuid.uuid4().hex
RULE_MAX_KBPS = 1500 RULE_MAX_KBPS = 1500
RULE_MAX_KBPS_NEW = 1800 RULE_MAX_KBPS_NEW = 1800
RULE_MAX_BURST_KBPS = 1100 RULE_MAX_BURST_KBPS = 1100
@@ -31,35 +28,36 @@ class TestQoSBandwidthLimitRule(base.BaseFunctionalTest):
RULE_DIRECTION = 'egress' RULE_DIRECTION = 'egress'
RULE_DIRECTION_NEW = 'ingress' RULE_DIRECTION_NEW = 'ingress'
@classmethod def setUp(self):
def setUpClass(cls): super(TestQoSBandwidthLimitRule, self).setUp()
super(TestQoSBandwidthLimitRule, cls).setUpClass() self.QOS_POLICY_NAME = self.getUniqueString()
qos_policy = cls.conn.network.create_qos_policy( self.RULE_ID = self.getUniqueString()
description=cls.QOS_POLICY_DESCRIPTION, qos_policy = self.conn.network.create_qos_policy(
name=cls.QOS_POLICY_NAME, description=self.QOS_POLICY_DESCRIPTION,
shared=cls.QOS_IS_SHARED, name=self.QOS_POLICY_NAME,
shared=self.QOS_IS_SHARED,
) )
cls.QOS_POLICY_ID = qos_policy.id self.QOS_POLICY_ID = qos_policy.id
qos_rule = cls.conn.network.create_qos_bandwidth_limit_rule( qos_rule = self.conn.network.create_qos_bandwidth_limit_rule(
cls.QOS_POLICY_ID, max_kbps=cls.RULE_MAX_KBPS, self.QOS_POLICY_ID, max_kbps=self.RULE_MAX_KBPS,
max_burst_kbps=cls.RULE_MAX_BURST_KBPS, max_burst_kbps=self.RULE_MAX_BURST_KBPS,
direction=cls.RULE_DIRECTION, direction=self.RULE_DIRECTION,
) )
assert isinstance(qos_rule, assert isinstance(qos_rule,
_qos_bandwidth_limit_rule.QoSBandwidthLimitRule) _qos_bandwidth_limit_rule.QoSBandwidthLimitRule)
cls.assertIs(cls.RULE_MAX_KBPS, qos_rule.max_kbps) self.assertEqual(self.RULE_MAX_KBPS, qos_rule.max_kbps)
cls.assertIs(cls.RULE_MAX_BURST_KBPS, qos_rule.max_burst_kbps) self.assertEqual(self.RULE_MAX_BURST_KBPS, qos_rule.max_burst_kbps)
cls.assertIs(cls.RULE_DIRECTION, qos_rule.direction) self.assertEqual(self.RULE_DIRECTION, qos_rule.direction)
cls.RULE_ID = qos_rule.id self.RULE_ID = qos_rule.id
@classmethod def tearDown(self):
def tearDownClass(cls): rule = self.conn.network.delete_qos_minimum_bandwidth_rule(
rule = cls.conn.network.delete_qos_minimum_bandwidth_rule( self.RULE_ID,
cls.RULE_ID, self.QOS_POLICY_ID)
cls.QOS_POLICY_ID) qos_policy = self.conn.network.delete_qos_policy(self.QOS_POLICY_ID)
qos_policy = cls.conn.network.delete_qos_policy(cls.QOS_POLICY_ID) self.assertIsNone(rule)
cls.assertIs(None, rule) self.assertIsNone(qos_policy)
cls.assertIs(None, qos_policy) super(TestQoSBandwidthLimitRule, self).tearDown()
def test_find(self): def test_find(self):
sot = self.conn.network.find_qos_bandwidth_limit_rule( sot = self.conn.network.find_qos_bandwidth_limit_rule(

44
openstack/tests/functional/network/v2/test_qos_dscp_marking_rule.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import (qos_dscp_marking_rule as from openstack.network.v2 import (qos_dscp_marking_rule as
_qos_dscp_marking_rule) _qos_dscp_marking_rule)
@@ -20,37 +19,36 @@ from openstack.tests.functional import base
class TestQoSDSCPMarkingRule(base.BaseFunctionalTest): class TestQoSDSCPMarkingRule(base.BaseFunctionalTest):
QOS_POLICY_ID = None QOS_POLICY_ID = None
QOS_POLICY_NAME = uuid.uuid4().hex
QOS_IS_SHARED = False QOS_IS_SHARED = False
QOS_POLICY_DESCRIPTION = "QoS policy description" QOS_POLICY_DESCRIPTION = "QoS policy description"
RULE_ID = uuid.uuid4().hex
RULE_DSCP_MARK = 36 RULE_DSCP_MARK = 36
RULE_DSCP_MARK_NEW = 40 RULE_DSCP_MARK_NEW = 40
@classmethod def setUp(self):
def setUpClass(cls): super(TestQoSDSCPMarkingRule, self).setUp()
super(TestQoSDSCPMarkingRule, cls).setUpClass() self.QOS_POLICY_NAME = self.getUniqueString()
qos_policy = cls.conn.network.create_qos_policy( self.RULE_ID = self.getUniqueString()
description=cls.QOS_POLICY_DESCRIPTION, qos_policy = self.conn.network.create_qos_policy(
name=cls.QOS_POLICY_NAME, description=self.QOS_POLICY_DESCRIPTION,
shared=cls.QOS_IS_SHARED, name=self.QOS_POLICY_NAME,
shared=self.QOS_IS_SHARED,
) )
cls.QOS_POLICY_ID = qos_policy.id self.QOS_POLICY_ID = qos_policy.id
qos_rule = cls.conn.network.create_qos_dscp_marking_rule( qos_rule = self.conn.network.create_qos_dscp_marking_rule(
cls.QOS_POLICY_ID, dscp_mark=cls.RULE_DSCP_MARK, self.QOS_POLICY_ID, dscp_mark=self.RULE_DSCP_MARK,
) )
assert isinstance(qos_rule, _qos_dscp_marking_rule.QoSDSCPMarkingRule) assert isinstance(qos_rule, _qos_dscp_marking_rule.QoSDSCPMarkingRule)
cls.assertIs(cls.RULE_DSCP_MARK, qos_rule.dscp_mark) self.assertEqual(self.RULE_DSCP_MARK, qos_rule.dscp_mark)
cls.RULE_ID = qos_rule.id self.RULE_ID = qos_rule.id
@classmethod def tearDown(self):
def tearDownClass(cls): rule = self.conn.network.delete_qos_minimum_bandwidth_rule(
rule = cls.conn.network.delete_qos_minimum_bandwidth_rule( self.RULE_ID,
cls.RULE_ID, self.QOS_POLICY_ID)
cls.QOS_POLICY_ID) qos_policy = self.conn.network.delete_qos_policy(self.QOS_POLICY_ID)
qos_policy = cls.conn.network.delete_qos_policy(cls.QOS_POLICY_ID) self.assertIsNone(rule)
cls.assertIs(None, rule) self.assertIsNone(qos_policy)
cls.assertIs(None, qos_policy) super(TestQoSDSCPMarkingRule, self).tearDown()
def test_find(self): def test_find(self):
sot = self.conn.network.find_qos_dscp_marking_rule( sot = self.conn.network.find_qos_dscp_marking_rule(

46
openstack/tests/functional/network/v2/test_qos_minimum_bandwidth_rule.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import (qos_minimum_bandwidth_rule as from openstack.network.v2 import (qos_minimum_bandwidth_rule as
_qos_minimum_bandwidth_rule) _qos_minimum_bandwidth_rule)
@@ -20,7 +19,6 @@ from openstack.tests.functional import base
class TestQoSMinimumBandwidthRule(base.BaseFunctionalTest): class TestQoSMinimumBandwidthRule(base.BaseFunctionalTest):
QOS_POLICY_ID = None QOS_POLICY_ID = None
QOS_POLICY_NAME = uuid.uuid4().hex
QOS_IS_SHARED = False QOS_IS_SHARED = False
QOS_POLICY_DESCRIPTION = "QoS policy description" QOS_POLICY_DESCRIPTION = "QoS policy description"
RULE_ID = None RULE_ID = None
@@ -28,33 +26,33 @@ class TestQoSMinimumBandwidthRule(base.BaseFunctionalTest):
RULE_MIN_KBPS_NEW = 1800 RULE_MIN_KBPS_NEW = 1800
RULE_DIRECTION = 'egress' RULE_DIRECTION = 'egress'
@classmethod def setUp(self):
def setUpClass(cls): super(TestQoSMinimumBandwidthRule, self).setUp()
super(TestQoSMinimumBandwidthRule, cls).setUpClass() self.QOS_POLICY_NAME = self.getUniqueString()
qos_policy = cls.conn.network.create_qos_policy( qos_policy = self.conn.network.create_qos_policy(
description=cls.QOS_POLICY_DESCRIPTION, description=self.QOS_POLICY_DESCRIPTION,
name=cls.QOS_POLICY_NAME, name=self.QOS_POLICY_NAME,
shared=cls.QOS_IS_SHARED, shared=self.QOS_IS_SHARED,
) )
cls.QOS_POLICY_ID = qos_policy.id self.QOS_POLICY_ID = qos_policy.id
qos_min_bw_rule = cls.conn.network.create_qos_minimum_bandwidth_rule( qos_min_bw_rule = self.conn.network.create_qos_minimum_bandwidth_rule(
cls.QOS_POLICY_ID, direction=cls.RULE_DIRECTION, self.QOS_POLICY_ID, direction=self.RULE_DIRECTION,
min_kbps=cls.RULE_MIN_KBPS, min_kbps=self.RULE_MIN_KBPS,
) )
assert isinstance(qos_min_bw_rule, assert isinstance(qos_min_bw_rule,
_qos_minimum_bandwidth_rule.QoSMinimumBandwidthRule) _qos_minimum_bandwidth_rule.QoSMinimumBandwidthRule)
cls.assertIs(cls.RULE_MIN_KBPS, qos_min_bw_rule.min_kbps) self.assertEqual(self.RULE_MIN_KBPS, qos_min_bw_rule.min_kbps)
cls.assertIs(cls.RULE_DIRECTION, qos_min_bw_rule.direction) self.assertEqual(self.RULE_DIRECTION, qos_min_bw_rule.direction)
cls.RULE_ID = qos_min_bw_rule.id self.RULE_ID = qos_min_bw_rule.id
@classmethod def tearDown(self):
def tearDownClass(cls): rule = self.conn.network.delete_qos_minimum_bandwidth_rule(
rule = cls.conn.network.delete_qos_minimum_bandwidth_rule( self.RULE_ID,
cls.RULE_ID, self.QOS_POLICY_ID)
cls.QOS_POLICY_ID) qos_policy = self.conn.network.delete_qos_policy(self.QOS_POLICY_ID)
qos_policy = cls.conn.network.delete_qos_policy(cls.QOS_POLICY_ID) self.assertIsNone(rule)
cls.assertIs(None, rule) self.assertIsNone(qos_policy)
cls.assertIs(None, qos_policy) super(TestQoSMinimumBandwidthRule, self).tearDown()
def test_find(self): def test_find(self):
sot = self.conn.network.find_qos_minimum_bandwidth_rule( sot = self.conn.network.find_qos_minimum_bandwidth_rule(

32
openstack/tests/functional/network/v2/test_qos_policy.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import qos_policy as _qos_policy from openstack.network.v2 import qos_policy as _qos_policy
from openstack.tests.functional import base from openstack.tests.functional import base
@@ -19,30 +18,29 @@ from openstack.tests.functional import base
class TestQoSPolicy(base.BaseFunctionalTest): class TestQoSPolicy(base.BaseFunctionalTest):
QOS_POLICY_ID = None QOS_POLICY_ID = None
QOS_POLICY_NAME = uuid.uuid4().hex
QOS_POLICY_NAME_UPDATED = uuid.uuid4().hex
IS_SHARED = False IS_SHARED = False
IS_DEFAULT = False IS_DEFAULT = False
RULES = [] RULES = []
QOS_POLICY_DESCRIPTION = "QoS policy description" QOS_POLICY_DESCRIPTION = "QoS policy description"
@classmethod def setUp(self):
def setUpClass(cls): super(TestQoSPolicy, self).setUp()
super(TestQoSPolicy, cls).setUpClass() self.QOS_POLICY_NAME = self.getUniqueString()
qos = cls.conn.network.create_qos_policy( self.QOS_POLICY_NAME_UPDATED = self.getUniqueString()
description=cls.QOS_POLICY_DESCRIPTION, qos = self.conn.network.create_qos_policy(
name=cls.QOS_POLICY_NAME, description=self.QOS_POLICY_DESCRIPTION,
shared=cls.IS_SHARED, name=self.QOS_POLICY_NAME,
is_default=cls.IS_DEFAULT, shared=self.IS_SHARED,
is_default=self.IS_DEFAULT,
) )
assert isinstance(qos, _qos_policy.QoSPolicy) assert isinstance(qos, _qos_policy.QoSPolicy)
cls.assertIs(cls.QOS_POLICY_NAME, qos.name) self.assertEqual(self.QOS_POLICY_NAME, qos.name)
cls.QOS_POLICY_ID = qos.id self.QOS_POLICY_ID = qos.id
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.network.delete_qos_policy(self.QOS_POLICY_ID)
sot = cls.conn.network.delete_qos_policy(cls.QOS_POLICY_ID) self.assertIsNone(sot)
cls.assertIs(None, sot) super(TestQoSPolicy, self).tearDown()
def test_find(self): def test_find(self):
sot = self.conn.network.find_qos_policy(self.QOS_POLICY_NAME) sot = self.conn.network.find_qos_policy(self.QOS_POLICY_NAME)

44
openstack/tests/functional/network/v2/test_rbac_policy.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import network from openstack.network.v2 import network
from openstack.network.v2 import rbac_policy from openstack.network.v2 import rbac_policy
@@ -19,37 +18,38 @@ from openstack.tests.functional import base
class TestRBACPolicy(base.BaseFunctionalTest): class TestRBACPolicy(base.BaseFunctionalTest):
NET_NAME = 'net-' + uuid.uuid4().hex
UPDATE_NAME = uuid.uuid4().hex
ACTION = 'access_as_shared' ACTION = 'access_as_shared'
OBJ_TYPE = 'network' OBJ_TYPE = 'network'
TARGET_TENANT_ID = '*' TARGET_TENANT_ID = '*'
NET_ID = None NET_ID = None
ID = None ID = None
@classmethod def setUp(self):
def setUpClass(cls): super(TestRBACPolicy, self).setUp()
super(TestRBACPolicy, cls).setUpClass() self.NET_NAME = self.getUniqueString('net')
net = cls.conn.network.create_network(name=cls.NET_NAME) self.UPDATE_NAME = self.getUniqueString()
net = self.conn.network.create_network(name=self.NET_NAME)
assert isinstance(net, network.Network) assert isinstance(net, network.Network)
cls.NET_ID = net.id self.NET_ID = net.id
sot = cls.conn.network.\ sot = self.conn.network.create_rbac_policy(
create_rbac_policy(action=cls.ACTION, action=self.ACTION,
object_type=cls.OBJ_TYPE, object_type=self.OBJ_TYPE,
target_tenant=cls.TARGET_TENANT_ID, target_tenant=self.TARGET_TENANT_ID,
object_id=cls.NET_ID) object_id=self.NET_ID)
assert isinstance(sot, rbac_policy.RBACPolicy) assert isinstance(sot, rbac_policy.RBACPolicy)
cls.ID = sot.id self.ID = sot.id
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.network.delete_rbac_policy(
sot = cls.conn.network.delete_rbac_policy(cls.ID, self.ID,
ignore_missing=False) ignore_missing=False)
cls.assertIs(None, sot) self.assertIsNone(sot)
sot = cls.conn.network.delete_network(cls.NET_ID, sot = self.conn.network.delete_network(
ignore_missing=False) self.NET_ID,
cls.assertIs(None, sot) ignore_missing=False)
self.assertIsNone(sot)
super(TestRBACPolicy, self).tearDown()
def test_find(self): def test_find(self):
sot = self.conn.network.find_rbac_policy(self.ID) sot = self.conn.network.find_rbac_policy(self.ID)

24
openstack/tests/functional/network/v2/test_router.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import router from openstack.network.v2 import router
from openstack.tests.functional import base from openstack.tests.functional import base
@@ -18,22 +17,21 @@ from openstack.tests.functional import base
class TestRouter(base.BaseFunctionalTest): class TestRouter(base.BaseFunctionalTest):
NAME = uuid.uuid4().hex
UPDATE_NAME = uuid.uuid4().hex
ID = None ID = None
@classmethod def setUp(self):
def setUpClass(cls): super(TestRouter, self).setUp()
super(TestRouter, cls).setUpClass() self.NAME = self.getUniqueString()
sot = cls.conn.network.create_router(name=cls.NAME) self.UPDATE_NAME = self.getUniqueString()
sot = self.conn.network.create_router(name=self.NAME)
assert isinstance(sot, router.Router) assert isinstance(sot, router.Router)
cls.assertIs(cls.NAME, sot.name) self.assertEqual(self.NAME, sot.name)
cls.ID = sot.id self.ID = sot.id
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.network.delete_router(self.ID, ignore_missing=False)
sot = cls.conn.network.delete_router(cls.ID, ignore_missing=False) self.assertIsNone(sot)
cls.assertIs(None, sot) super(TestRouter, self).tearDown()
def test_find(self): def test_find(self):
sot = self.conn.network.find_router(self.NAME) sot = self.conn.network.find_router(self.NAME)

63
openstack/tests/functional/network/v2/test_router_add_remove_interface.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import network from openstack.network.v2 import network
from openstack.network.v2 import router from openstack.network.v2 import router
@@ -20,9 +19,6 @@ from openstack.tests.functional import base
class TestRouterInterface(base.BaseFunctionalTest): class TestRouterInterface(base.BaseFunctionalTest):
ROUTER_NAME = uuid.uuid4().hex
NET_NAME = uuid.uuid4().hex
SUB_NAME = uuid.uuid4().hex
CIDR = "10.100.0.0/16" CIDR = "10.100.0.0/16"
IPV4 = 4 IPV4 = 4
ROUTER_ID = None ROUTER_ID = None
@@ -30,42 +26,45 @@ class TestRouterInterface(base.BaseFunctionalTest):
SUB_ID = None SUB_ID = None
ROT = None ROT = None
@classmethod def setUp(self):
def setUpClass(cls): super(TestRouterInterface, self).setUp()
super(TestRouterInterface, cls).setUpClass() self.ROUTER_NAME = self.getUniqueString()
sot = cls.conn.network.create_router(name=cls.ROUTER_NAME) self.NET_NAME = self.getUniqueString()
self.SUB_NAME = self.getUniqueString()
sot = self.conn.network.create_router(name=self.ROUTER_NAME)
assert isinstance(sot, router.Router) assert isinstance(sot, router.Router)
cls.assertIs(cls.ROUTER_NAME, sot.name) self.assertEqual(self.ROUTER_NAME, sot.name)
net = cls.conn.network.create_network(name=cls.NET_NAME) net = self.conn.network.create_network(name=self.NET_NAME)
assert isinstance(net, network.Network) assert isinstance(net, network.Network)
cls.assertIs(cls.NET_NAME, net.name) self.assertEqual(self.NET_NAME, net.name)
sub = cls.conn.network.create_subnet(name=cls.SUB_NAME, sub = self.conn.network.create_subnet(
ip_version=cls.IPV4, name=self.SUB_NAME,
network_id=net.id, ip_version=self.IPV4,
cidr=cls.CIDR) network_id=net.id,
cidr=self.CIDR)
assert isinstance(sub, subnet.Subnet) assert isinstance(sub, subnet.Subnet)
cls.assertIs(cls.SUB_NAME, sub.name) self.assertEqual(self.SUB_NAME, sub.name)
cls.ROUTER_ID = sot.id self.ROUTER_ID = sot.id
cls.ROT = sot self.ROT = sot
cls.NET_ID = net.id self.NET_ID = net.id
cls.SUB_ID = sub.id self.SUB_ID = sub.id
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.network.delete_router(
sot = cls.conn.network.delete_router(cls.ROUTER_ID, self.ROUTER_ID, ignore_missing=False)
ignore_missing=False) self.assertIsNone(sot)
cls.assertIs(None, sot) sot = self.conn.network.delete_subnet(
sot = cls.conn.network.delete_subnet(cls.SUB_ID, ignore_missing=False) self.SUB_ID, ignore_missing=False)
cls.assertIs(None, sot) self.assertIsNone(sot)
sot = cls.conn.network.delete_network(cls.NET_ID, ignore_missing=False) sot = self.conn.network.delete_network(
cls.assertIs(None, sot) self.NET_ID, ignore_missing=False)
self.assertIsNone(sot)
super(TestRouterInterface, self).tearDown()
def test_router_add_interface(self): def test_router_add_remove_interface(self):
iface = self.ROT.add_interface(self.conn.session, iface = self.ROT.add_interface(self.conn.session,
subnet_id=self.SUB_ID) subnet_id=self.SUB_ID)
self._verification(iface) self._verification(iface)
def test_router_remove_interface(self):
iface = self.ROT.remove_interface(self.conn.session, iface = self.ROT.remove_interface(self.conn.session,
subnet_id=self.SUB_ID) subnet_id=self.SUB_ID)
self._verification(iface) self._verification(iface)

24
openstack/tests/functional/network/v2/test_security_group.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import security_group from openstack.network.v2 import security_group
from openstack.tests.functional import base from openstack.tests.functional import base
@@ -18,22 +17,21 @@ from openstack.tests.functional import base
class TestSecurityGroup(base.BaseFunctionalTest): class TestSecurityGroup(base.BaseFunctionalTest):
NAME = uuid.uuid4().hex
ID = None ID = None
@classmethod def setUp(self):
def setUpClass(cls): super(TestSecurityGroup, self).setUp()
super(TestSecurityGroup, cls).setUpClass() self.NAME = self.getUniqueString()
sot = cls.conn.network.create_security_group(name=cls.NAME) sot = self.conn.network.create_security_group(name=self.NAME)
assert isinstance(sot, security_group.SecurityGroup) assert isinstance(sot, security_group.SecurityGroup)
cls.assertIs(cls.NAME, sot.name) self.assertEqual(self.NAME, sot.name)
cls.ID = sot.id self.ID = sot.id
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.network.delete_security_group(
sot = cls.conn.network.delete_security_group(cls.ID, self.ID, ignore_missing=False)
ignore_missing=False) self.assertIsNone(sot)
cls.assertIs(None, sot) super(TestSecurityGroup, self).tearDown()
def test_find(self): def test_find(self):
sot = self.conn.network.find_security_group(self.NAME) sot = self.conn.network.find_security_group(self.NAME)

42
openstack/tests/functional/network/v2/test_security_group_rule.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import security_group from openstack.network.v2 import security_group
from openstack.network.v2 import security_group_rule from openstack.network.v2 import security_group_rule
@@ -19,7 +18,6 @@ from openstack.tests.functional import base
class TestSecurityGroupRule(base.BaseFunctionalTest): class TestSecurityGroupRule(base.BaseFunctionalTest):
NAME = uuid.uuid4().hex
IPV4 = 'IPv4' IPV4 = 'IPv4'
PROTO = 'tcp' PROTO = 'tcp'
PORT = 22 PORT = 22
@@ -27,29 +25,29 @@ class TestSecurityGroupRule(base.BaseFunctionalTest):
ID = None ID = None
RULE_ID = None RULE_ID = None
@classmethod def setUp(self):
def setUpClass(cls): super(TestSecurityGroupRule, self).setUp()
super(TestSecurityGroupRule, cls).setUpClass() self.NAME = self.getUniqueString()
sot = cls.conn.network.create_security_group(name=cls.NAME) sot = self.conn.network.create_security_group(name=self.NAME)
assert isinstance(sot, security_group.SecurityGroup) assert isinstance(sot, security_group.SecurityGroup)
cls.assertIs(cls.NAME, sot.name) self.assertEqual(self.NAME, sot.name)
cls.ID = sot.id self.ID = sot.id
rul = cls.conn.network.create_security_group_rule( rul = self.conn.network.create_security_group_rule(
direction=cls.DIR, ethertype=cls.IPV4, direction=self.DIR, ethertype=self.IPV4,
port_range_max=cls.PORT, port_range_min=cls.PORT, port_range_max=self.PORT, port_range_min=self.PORT,
protocol=cls.PROTO, security_group_id=cls.ID) protocol=self.PROTO, security_group_id=self.ID)
assert isinstance(rul, security_group_rule.SecurityGroupRule) assert isinstance(rul, security_group_rule.SecurityGroupRule)
cls.assertIs(cls.ID, rul.security_group_id) self.assertEqual(self.ID, rul.security_group_id)
cls.RULE_ID = rul.id self.RULE_ID = rul.id
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.network.delete_security_group_rule(
sot = cls.conn.network.delete_security_group_rule(cls.RULE_ID, self.RULE_ID, ignore_missing=False)
ignore_missing=False) self.assertIsNone(sot)
cls.assertIs(None, sot) sot = self.conn.network.delete_security_group(
sot = cls.conn.network.delete_security_group(cls.ID, self.ID, ignore_missing=False)
ignore_missing=False) self.assertIsNone(sot)
cls.assertIs(None, sot) super(TestSecurityGroupRule, self).tearDown()
def test_find(self): def test_find(self):
sot = self.conn.network.find_security_group_rule(self.RULE_ID) sot = self.conn.network.find_security_group_rule(self.RULE_ID)

117
openstack/tests/functional/network/v2/test_segment.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import network from openstack.network.v2 import network
from openstack.network.v2 import segment from openstack.network.v2 import segment
@@ -19,7 +18,6 @@ from openstack.tests.functional import base
class TestSegment(base.BaseFunctionalTest): class TestSegment(base.BaseFunctionalTest):
NETWORK_NAME = uuid.uuid4().hex
NETWORK_TYPE = None NETWORK_TYPE = None
PHYSICAL_NETWORK = None PHYSICAL_NETWORK = None
SEGMENTATION_ID = None SEGMENTATION_ID = None
@@ -27,88 +25,75 @@ class TestSegment(base.BaseFunctionalTest):
SEGMENT_ID = None SEGMENT_ID = None
SEGMENT_EXTENSION = None SEGMENT_EXTENSION = None
@classmethod def setUp(self):
def setUpClass(cls): super(TestSegment, self).setUp()
super(TestSegment, cls).setUpClass() self.NETWORK_NAME = self.getUniqueString()
# NOTE(rtheis): The segment extension is not yet enabled by default. # NOTE(rtheis): The segment extension is not yet enabled by default.
# Skip the tests if not enabled. # Skip the tests if not enabled.
cls.SEGMENT_EXTENSION = cls.conn.network.find_extension('segment') if not self.conn.network.find_extension('segment'):
self.skipTest('Segment extension disabled')
# Create a network to hold the segment. # Create a network to hold the segment.
net = cls.conn.network.create_network(name=cls.NETWORK_NAME) net = self.conn.network.create_network(name=self.NETWORK_NAME)
assert isinstance(net, network.Network) assert isinstance(net, network.Network)
cls.assertIs(cls.NETWORK_NAME, net.name) self.assertEqual(self.NETWORK_NAME, net.name)
cls.NETWORK_ID = net.id self.NETWORK_ID = net.id
if cls.SEGMENT_EXTENSION: if self.SEGMENT_EXTENSION:
# Get the segment for the network. # Get the segment for the network.
for seg in cls.conn.network.segments(): for seg in self.conn.network.segments():
assert isinstance(seg, segment.Segment) assert isinstance(seg, segment.Segment)
if cls.NETWORK_ID == seg.network_id: if self.NETWORK_ID == seg.network_id:
cls.NETWORK_TYPE = seg.network_type self.NETWORK_TYPE = seg.network_type
cls.PHYSICAL_NETWORK = seg.physical_network self.PHYSICAL_NETWORK = seg.physical_network
cls.SEGMENTATION_ID = seg.segmentation_id self.SEGMENTATION_ID = seg.segmentation_id
cls.SEGMENT_ID = seg.id self.SEGMENT_ID = seg.id
break break
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.network.delete_network(
sot = cls.conn.network.delete_network(cls.NETWORK_ID, self.NETWORK_ID,
ignore_missing=False) ignore_missing=False)
cls.assertIs(None, sot) self.assertIsNone(sot)
super(TestSegment, self).tearDown()
def test_create_delete(self): def test_create_delete(self):
if self.SEGMENT_EXTENSION: sot = self.conn.network.create_segment(
sot = self.conn.network.create_segment( description='test description',
description='test description', name='test name',
name='test name', network_id=self.NETWORK_ID,
network_id=self.NETWORK_ID, network_type='geneve',
network_type='geneve', segmentation_id=2055,
segmentation_id=2055, )
) self.assertIsInstance(sot, segment.Segment)
self.assertIsInstance(sot, segment.Segment) del_sot = self.conn.network.delete_segment(sot.id)
del_sot = self.conn.network.delete_segment(sot.id) self.assertEqual('test description', sot.description)
self.assertEqual('test description', sot.description) self.assertEqual('test name', sot.name)
self.assertEqual('test name', sot.name) self.assertEqual(self.NETWORK_ID, sot.network_id)
self.assertEqual(self.NETWORK_ID, sot.network_id) self.assertEqual('geneve', sot.network_type)
self.assertEqual('geneve', sot.network_type) self.assertIsNone(sot.physical_network)
self.assertIsNone(sot.physical_network) self.assertEqual(2055, sot.segmentation_id)
self.assertEqual(2055, sot.segmentation_id) self.assertIsNone(del_sot)
self.assertIsNone(del_sot)
else:
self.skipTest('Segment extension disabled')
def test_find(self): def test_find(self):
if self.SEGMENT_EXTENSION: sot = self.conn.network.find_segment(self.SEGMENT_ID)
sot = self.conn.network.find_segment(self.SEGMENT_ID) self.assertEqual(self.SEGMENT_ID, sot.id)
self.assertEqual(self.SEGMENT_ID, sot.id)
else:
self.skipTest('Segment extension disabled')
def test_get(self): def test_get(self):
if self.SEGMENT_EXTENSION: sot = self.conn.network.get_segment(self.SEGMENT_ID)
sot = self.conn.network.get_segment(self.SEGMENT_ID) self.assertEqual(self.SEGMENT_ID, sot.id)
self.assertEqual(self.SEGMENT_ID, sot.id) self.assertIsNone(sot.name)
self.assertIsNone(sot.name) self.assertEqual(self.NETWORK_ID, sot.network_id)
self.assertEqual(self.NETWORK_ID, sot.network_id) self.assertEqual(self.NETWORK_TYPE, sot.network_type)
self.assertEqual(self.NETWORK_TYPE, sot.network_type) self.assertEqual(self.PHYSICAL_NETWORK, sot.physical_network)
self.assertEqual(self.PHYSICAL_NETWORK, sot.physical_network) self.assertEqual(self.SEGMENTATION_ID, sot.segmentation_id)
self.assertEqual(self.SEGMENTATION_ID, sot.segmentation_id)
else:
self.skipTest('Segment extension disabled')
def test_list(self): def test_list(self):
if self.SEGMENT_EXTENSION: ids = [o.id for o in self.conn.network.segments(name=None)]
ids = [o.id for o in self.conn.network.segments(name=None)] self.assertIn(self.SEGMENT_ID, ids)
self.assertIn(self.SEGMENT_ID, ids)
else:
self.skipTest('Segment extension disabled')
def test_update(self): def test_update(self):
if self.SEGMENT_EXTENSION: sot = self.conn.network.update_segment(self.SEGMENT_ID,
sot = self.conn.network.update_segment(self.SEGMENT_ID, description='update')
description='update') self.assertEqual('update', sot.description)
self.assertEqual('update', sot.description)
else:
self.skipTest('Segment extension disabled')

30
openstack/tests/functional/network/v2/test_service_profile.py
View File

@@ -21,25 +21,25 @@ class TestServiceProfile(base.BaseFunctionalTest):
METAINFO = "FlAVOR_PROFILE_METAINFO" METAINFO = "FlAVOR_PROFILE_METAINFO"
ID = None ID = None
@classmethod def setUp(self):
def setUpClass(cls): super(TestServiceProfile, self).setUp()
super(TestServiceProfile, cls).setUpClass() service_profiles = self.conn.network.create_service_profile(
service_profiles = cls.conn.network.create_service_profile( description=self.SERVICE_PROFILE_DESCRIPTION,
description=cls.SERVICE_PROFILE_DESCRIPTION, metainfo=self.METAINFO,)
metainfo=cls.METAINFO,)
assert isinstance(service_profiles, _service_profile.ServiceProfile) assert isinstance(service_profiles, _service_profile.ServiceProfile)
cls.assertIs(cls.SERVICE_PROFILE_DESCRIPTION, self.assertEqual(
service_profiles.description) self.SERVICE_PROFILE_DESCRIPTION,
cls.assertIs(cls.METAINFO, service_profiles.meta_info) service_profiles.description)
self.assertEqual(self.METAINFO, service_profiles.meta_info)
cls.ID = service_profiles.id self.ID = service_profiles.id
@classmethod def tearDown(self):
def tearDownClass(cls): service_profiles = self.conn.network.delete_service_profile(
service_profiles = cls.conn.network.delete_service_profile( self.ID,
cls.ID,
ignore_missing=True) ignore_missing=True)
cls.assertIs(None, service_profiles) self.assertIsNone(service_profiles)
super(TestServiceProfile, self).tearDown()
def test_find(self): def test_find(self):
service_profiles = self.conn.network.find_service_profile( service_profiles = self.conn.network.find_service_profile(

50
openstack/tests/functional/network/v2/test_subnet.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import network from openstack.network.v2 import network
from openstack.network.v2 import subnet from openstack.network.v2 import subnet
@@ -19,9 +18,6 @@ from openstack.tests.functional import base
class TestSubnet(base.BaseFunctionalTest): class TestSubnet(base.BaseFunctionalTest):
NET_NAME = uuid.uuid4().hex
SUB_NAME = uuid.uuid4().hex
UPDATE_NAME = uuid.uuid4().hex
IPV4 = 4 IPV4 = 4
CIDR = "10.100.0.0/24" CIDR = "10.100.0.0/24"
DNS_SERVERS = ["8.8.4.4", "8.8.8.8"] DNS_SERVERS = ["8.8.4.4", "8.8.8.8"]
@@ -30,30 +26,34 @@ class TestSubnet(base.BaseFunctionalTest):
NET_ID = None NET_ID = None
SUB_ID = None SUB_ID = None
@classmethod def setUp(self):
def setUpClass(cls): super(TestSubnet, self).setUp()
super(TestSubnet, cls).setUpClass() self.NET_NAME = self.getUniqueString()
net = cls.conn.network.create_network(name=cls.NET_NAME) self.SUB_NAME = self.getUniqueString()
self.UPDATE_NAME = self.getUniqueString()
net = self.conn.network.create_network(name=self.NET_NAME)
assert isinstance(net, network.Network) assert isinstance(net, network.Network)
cls.assertIs(cls.NET_NAME, net.name) self.assertEqual(self.NET_NAME, net.name)
cls.NET_ID = net.id self.NET_ID = net.id
sub = cls.conn.network.create_subnet(name=cls.SUB_NAME, sub = self.conn.network.create_subnet(
ip_version=cls.IPV4, name=self.SUB_NAME,
network_id=cls.NET_ID, ip_version=self.IPV4,
cidr=cls.CIDR, network_id=self.NET_ID,
dns_nameservers=cls.DNS_SERVERS, cidr=self.CIDR,
allocation_pools=cls.POOL, dns_nameservers=self.DNS_SERVERS,
host_routes=cls.ROUTES) allocation_pools=self.POOL,
host_routes=self.ROUTES)
assert isinstance(sub, subnet.Subnet) assert isinstance(sub, subnet.Subnet)
cls.assertIs(cls.SUB_NAME, sub.name) self.assertEqual(self.SUB_NAME, sub.name)
cls.SUB_ID = sub.id self.SUB_ID = sub.id
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.network.delete_subnet(self.SUB_ID)
sot = cls.conn.network.delete_subnet(cls.SUB_ID) self.assertIsNone(sot)
cls.assertIs(None, sot) sot = self.conn.network.delete_network(
sot = cls.conn.network.delete_network(cls.NET_ID, ignore_missing=False) self.NET_ID, ignore_missing=False)
cls.assertIs(None, sot) self.assertIsNone(sot)
super(TestSubnet, self).tearDown()
def test_find(self): def test_find(self):
sot = self.conn.network.find_subnet(self.SUB_NAME) sot = self.conn.network.find_subnet(self.SUB_NAME)

38
openstack/tests/functional/network/v2/test_subnet_pool.py
View File

@@ -10,7 +10,6 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import uuid
from openstack.network.v2 import subnet_pool as _subnet_pool from openstack.network.v2 import subnet_pool as _subnet_pool
from openstack.tests.functional import base from openstack.tests.functional import base
@@ -18,8 +17,6 @@ from openstack.tests.functional import base
class TestSubnetPool(base.BaseFunctionalTest): class TestSubnetPool(base.BaseFunctionalTest):
SUBNET_POOL_NAME = uuid.uuid4().hex
SUBNET_POOL_NAME_UPDATED = uuid.uuid4().hex
SUBNET_POOL_ID = None SUBNET_POOL_ID = None
MINIMUM_PREFIX_LENGTH = 8 MINIMUM_PREFIX_LENGTH = 8
DEFAULT_PREFIX_LENGTH = 24 DEFAULT_PREFIX_LENGTH = 24
@@ -29,25 +26,26 @@ class TestSubnetPool(base.BaseFunctionalTest):
IP_VERSION = 4 IP_VERSION = 4
PREFIXES = ['10.100.0.0/24', '10.101.0.0/24'] PREFIXES = ['10.100.0.0/24', '10.101.0.0/24']
@classmethod def setUp(self):
def setUpClass(cls): super(TestSubnetPool, self).setUp()
super(TestSubnetPool, cls).setUpClass() self.SUBNET_POOL_NAME = self.getUniqueString()
subnet_pool = cls.conn.network.create_subnet_pool( self.SUBNET_POOL_NAME_UPDATED = self.getUniqueString()
name=cls.SUBNET_POOL_NAME, subnet_pool = self.conn.network.create_subnet_pool(
min_prefixlen=cls.MINIMUM_PREFIX_LENGTH, name=self.SUBNET_POOL_NAME,
default_prefixlen=cls.DEFAULT_PREFIX_LENGTH, min_prefixlen=self.MINIMUM_PREFIX_LENGTH,
max_prefixlen=cls.MAXIMUM_PREFIX_LENGTH, default_prefixlen=self.DEFAULT_PREFIX_LENGTH,
default_quota=cls.DEFAULT_QUOTA, max_prefixlen=self.MAXIMUM_PREFIX_LENGTH,
shared=cls.IS_SHARED, default_quota=self.DEFAULT_QUOTA,
prefixes=cls.PREFIXES) shared=self.IS_SHARED,
prefixes=self.PREFIXES)
assert isinstance(subnet_pool, _subnet_pool.SubnetPool) assert isinstance(subnet_pool, _subnet_pool.SubnetPool)
cls.assertIs(cls.SUBNET_POOL_NAME, subnet_pool.name) self.assertEqual(self.SUBNET_POOL_NAME, subnet_pool.name)
cls.SUBNET_POOL_ID = subnet_pool.id self.SUBNET_POOL_ID = subnet_pool.id
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.network.delete_subnet_pool(self.SUBNET_POOL_ID)
sot = cls.conn.network.delete_subnet_pool(cls.SUBNET_POOL_ID) self.assertIsNone(sot)
cls.assertIs(None, sot) super(TestSubnetPool, self).tearDown()
def test_find(self): def test_find(self):
sot = self.conn.network.find_subnet_pool(self.SUBNET_POOL_NAME) sot = self.conn.network.find_subnet_pool(self.SUBNET_POOL_NAME)

17
openstack/tests/functional/object_store/v1/test_account.py
View File

@@ -10,20 +10,19 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import unittest
from openstack.tests.functional import base from openstack.tests.functional import base
@unittest.skipUnless(base.service_exists(service_type='object-store'),
'Object Storage service does not exist')
class TestAccount(base.BaseFunctionalTest): class TestAccount(base.BaseFunctionalTest):
@classmethod def setUp(self):
def tearDownClass(cls): super(TestAccount, self).setUp()
super(TestAccount, cls).tearDownClass() self.require_service('object-store')
account = cls.conn.object_store.get_account_metadata()
cls.conn.object_store.delete_account_metadata(account.metadata.keys()) def tearDown(self):
account = self.conn.object_store.get_account_metadata()
self.conn.object_store.delete_account_metadata(account.metadata.keys())
super(TestAccount, self).tearDown()
def test_system_metadata(self): def test_system_metadata(self):
account = self.conn.object_store.get_account_metadata() account = self.conn.object_store.get_account_metadata()

26
openstack/tests/functional/object_store/v1/test_container.py
View File

@@ -10,31 +10,23 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import unittest
import uuid
from openstack.object_store.v1 import container as _container from openstack.object_store.v1 import container as _container
from openstack.tests.functional import base from openstack.tests.functional import base
@unittest.skipUnless(base.service_exists(service_type='object-store'),
'Object Storage service does not exist')
class TestContainer(base.BaseFunctionalTest): class TestContainer(base.BaseFunctionalTest):
NAME = uuid.uuid4().hex def setUp(self):
super(TestContainer, self).setUp()
self.require_service('object-store')
@classmethod self.NAME = self.getUniqueString()
def setUpClass(cls): container = self.conn.object_store.create_container(name=self.NAME)
super(TestContainer, cls).setUpClass() self.addEmptyCleanup(
container = cls.conn.object_store.create_container(name=cls.NAME) self.conn.object_store.delete_container,
self.NAME, ignore_missing=False)
assert isinstance(container, _container.Container) assert isinstance(container, _container.Container)
cls.assertIs(cls.NAME, container.name) self.assertEqual(self.NAME, container.name)
@classmethod
def tearDownClass(cls):
result = cls.conn.object_store.delete_container(cls.NAME,
ignore_missing=False)
cls.assertIs(None, result)
def test_list(self): def test_list(self):
names = [o.name for o in self.conn.object_store.containers()] names = [o.name for o in self.conn.object_store.containers()]

30
openstack/tests/functional/object_store/v1/test_obj.py
View File

@@ -10,32 +10,26 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import unittest
import uuid
from openstack.tests.functional import base from openstack.tests.functional import base
@unittest.skipUnless(base.service_exists(service_type='object-store'),
'Object Storage service does not exist')
class TestObject(base.BaseFunctionalTest): class TestObject(base.BaseFunctionalTest):
FOLDER = uuid.uuid4().hex
FILE = uuid.uuid4().hex
DATA = b'abc' DATA = b'abc'
@classmethod def setUp(self):
def setUpClass(cls): super(TestObject, self).setUp()
super(TestObject, cls).setUpClass() self.require_service('object-store')
cls.conn.object_store.create_container(name=cls.FOLDER)
cls.sot = cls.conn.object_store.upload_object(
container=cls.FOLDER, name=cls.FILE, data=cls.DATA)
@classmethod self.FOLDER = self.getUniqueString()
def tearDownClass(cls): self.FILE = self.getUniqueString()
super(TestObject, cls).tearDownClass() self.conn.object_store.create_container(name=self.FOLDER)
cls.conn.object_store.delete_object(cls.sot, ignore_missing=False) self.addCleanup(self.conn.object_store.delete_container, self.FOLDER)
cls.conn.object_store.delete_container(cls.FOLDER) self.sot = self.conn.object_store.upload_object(
container=self.FOLDER, name=self.FILE, data=self.DATA)
self.addEmptyCleanup(
self.conn.object_store.delete_object, self.sot,
ignore_missing=False)
def test_list(self): def test_list(self):
names = [o.name for o names = [o.name for o

57
openstack/tests/functional/orchestration/v1/test_stack.py
View File

@@ -10,6 +10,7 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import time
import unittest import unittest
from openstack import exceptions from openstack import exceptions
@@ -19,8 +20,6 @@ from openstack.tests.functional.network.v2 import test_network
@unittest.skip("bug/1525005") @unittest.skip("bug/1525005")
@unittest.skipUnless(base.service_exists(service_type='orchestration'),
'Orchestration service does not exist')
class TestStack(base.BaseFunctionalTest): class TestStack(base.BaseFunctionalTest):
NAME = 'test_stack' NAME = 'test_stack'
@@ -29,48 +28,50 @@ class TestStack(base.BaseFunctionalTest):
subnet = None subnet = None
cidr = '10.99.99.0/16' cidr = '10.99.99.0/16'
@classmethod def setUp(self):
def setUpClass(cls): super(TestStack, self).setUp()
super(TestStack, cls).setUpClass() self.require_service('orchestration')
if cls.conn.compute.find_keypair(cls.NAME) is None:
cls.conn.compute.create_keypair(name=cls.NAME) if self.conn.compute.find_keypair(self.NAME) is None:
image = next(cls.conn.image.images()) self.conn.compute.create_keypair(name=self.NAME)
image = next(self.conn.image.images())
tname = "openstack/tests/functional/orchestration/v1/hello_world.yaml" tname = "openstack/tests/functional/orchestration/v1/hello_world.yaml"
with open(tname) as f: with open(tname) as f:
template = f.read() template = f.read()
cls.network, cls.subnet = test_network.create_network(cls.conn, self.network, self.subnet = test_network.create_network(
cls.NAME, self.conn,
cls.cidr) self.NAME,
self.cidr)
parameters = { parameters = {
'image': image.id, 'image': image.id,
'key_name': cls.NAME, 'key_name': self.NAME,
'network': cls.network.id, 'network': self.network.id,
} }
sot = cls.conn.orchestration.create_stack( sot = self.conn.orchestration.create_stack(
name=cls.NAME, name=self.NAME,
parameters=parameters, parameters=parameters,
template=template, template=template,
) )
assert isinstance(sot, stack.Stack) assert isinstance(sot, stack.Stack)
cls.assertIs(True, (sot.id is not None)) self.assertEqual(True, (sot.id is not None))
cls.stack = sot self.stack = sot
cls.assertIs(cls.NAME, sot.name) self.assertEqual(self.NAME, sot.name)
cls.conn.orchestration.wait_for_status( self.conn.orchestration.wait_for_status(
sot, status='CREATE_COMPLETE', failures=['CREATE_FAILED']) sot, status='CREATE_COMPLETE', failures=['CREATE_FAILED'])
@classmethod def tearDown(self):
def tearDownClass(cls): self.conn.orchestration.delete_stack(self.stack, ignore_missing=False)
super(TestStack, cls).tearDownClass() self.conn.compute.delete_keypair(self.NAME)
cls.conn.orchestration.delete_stack(cls.stack, ignore_missing=False)
cls.conn.compute.delete_keypair(cls.NAME)
# Need to wait for the stack to go away before network delete # Need to wait for the stack to go away before network delete
try: try:
cls.conn.orchestration.wait_for_status( self.conn.orchestration.wait_for_status(
cls.stack, 'DELETE_COMPLETE') self.stack, 'DELETE_COMPLETE')
except exceptions.NotFoundException: except exceptions.NotFoundException:
pass pass
cls.linger_for_delete() # TODO(shade) sleeping in tests is bad mmkay?
test_network.delete_network(cls.conn, cls.network, cls.subnet) time.sleep(40)
test_network.delete_network(self.conn, self.network, self.subnet)
super(TestStack, self).tearDown()
def test_list(self): def test_list(self):
names = [o.name for o in self.conn.orchestration.stacks()] names = [o.name for o in self.conn.orchestration.stacks()]

33
openstack/tests/functional/telemetry/alarm/v2/test_alarm.py
View File

@@ -11,28 +11,25 @@
# under the License. # under the License.
import unittest import unittest
import uuid
from openstack.telemetry.alarm.v2 import alarm from openstack.telemetry.alarm.v2 import alarm
from openstack.tests.functional import base from openstack.tests.functional import base
@unittest.skip("bug/1524468") @unittest.skip("bug/1524468")
@unittest.skipUnless(base.service_exists(service_type="alarming"),
"Alarming service does not exist")
@unittest.skipUnless(base.service_exists(service_type="metering"),
"Metering service does not exist")
class TestAlarm(base.BaseFunctionalTest): class TestAlarm(base.BaseFunctionalTest):
NAME = uuid.uuid4().hex
ID = None ID = None
@classmethod def setUp(self):
def setUpClass(cls): super(TestAlarm, self).setUp()
super(TestAlarm, cls).setUpClass() self.require_service('alarming')
meter = next(cls.conn.telemetry.meters()) self.require_service('metering')
sot = cls.conn.alarm.create_alarm(
name=cls.NAME, self.NAME = self.getUniqueString()
meter = next(self.conn.telemetry.meters())
sot = self.conn.alarm.create_alarm(
name=self.NAME,
type='threshold', type='threshold',
threshold_rule={ threshold_rule={
'meter_name': meter.name, 'meter_name': meter.name,
@@ -40,13 +37,13 @@ class TestAlarm(base.BaseFunctionalTest):
}, },
) )
assert isinstance(sot, alarm.Alarm) assert isinstance(sot, alarm.Alarm)
cls.assertIs(cls.NAME, sot.name) self.assertEqual(self.NAME, sot.name)
cls.ID = sot.id self.ID = sot.id
@classmethod def tearDown(self):
def tearDownClass(cls): sot = self.conn.alarm.delete_alarm(self.ID, ignore_missing=False)
sot = cls.conn.alarm.delete_alarm(cls.ID, ignore_missing=False) self.assertIsNone(sot)
cls.assertIs(None, sot) super(TestAlarm, self).tearDown()
def test_get(self): def test_get(self):
sot = self.conn.alarm.get_alarm(self.ID) sot = self.conn.alarm.get_alarm(self.ID)

28
openstack/tests/functional/telemetry/alarm/v2/test_alarm_change.py
View File

@@ -11,38 +11,32 @@
# under the License. # under the License.
import unittest import unittest
import uuid
from openstack.tests.functional import base from openstack.tests.functional import base
@unittest.skip("bug/1524468") @unittest.skip("bug/1524468")
@unittest.skipUnless(base.service_exists(service_type="metering"),
"Metering service does not exist")
@unittest.skipUnless(base.service_exists(service_type="alarming"),
"Alarming service does not exist")
class TestAlarmChange(base.BaseFunctionalTest): class TestAlarmChange(base.BaseFunctionalTest):
NAME = uuid.uuid4().hex
alarm = None alarm = None
@classmethod def setUp(self):
def setUpClass(cls): super(TestAlarmChange, self).setUp()
super(TestAlarmChange, cls).setUpClass() self.require_service('alarming')
meter = next(cls.conn.telemetry.meters()) self.require_service('metering')
alarm = cls.conn.alarm.create_alarm(
name=cls.NAME, self.NAME = self.getUniqueString()
meter = next(self.conn.telemetry.meters())
self.alarm = self.conn.alarm.create_alarm(
name=self.NAME,
type='threshold', type='threshold',
threshold_rule={ threshold_rule={
'meter_name': meter.name, 'meter_name': meter.name,
'threshold': 1.1, 'threshold': 1.1,
}, },
) )
cls.alarm = alarm self.addCleanup(
self.conn.alarm.delete_alarm, self.alarm, ignore_missing=False)
@classmethod
def tearDownClass(cls):
cls.conn.alarm.delete_alarm(cls.alarm, ignore_missing=False)
def test_list(self): def test_list(self):
change = next(self.conn.alarm.alarm_changes(self.alarm)) change = next(self.conn.alarm.alarm_changes(self.alarm))

8
openstack/tests/functional/telemetry/v2/test_capability.py
View File

@@ -10,15 +10,15 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import unittest
from openstack.tests.functional import base from openstack.tests.functional import base
@unittest.skipUnless(base.service_exists(service_type="metering"),
"Metering service does not exist")
class TestCapability(base.BaseFunctionalTest): class TestCapability(base.BaseFunctionalTest):
def setUp(self):
super(TestCapability, self).setUp()
self.require_service('metering')
def test_list(self): def test_list(self):
ids = [o.id for o in self.conn.telemetry.capabilities()] ids = [o.id for o in self.conn.telemetry.capabilities()]
self.assertIn('resources:query:simple', ids) self.assertIn('resources:query:simple', ids)

11
openstack/tests/functional/telemetry/v2/test_meter.py
View File

@@ -10,21 +10,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.
import unittest
import uuid
from openstack.tests.functional import base from openstack.tests.functional import base
@unittest.skipUnless(base.service_exists(service_type="metering"),
"Metering service does not exist")
class TestMeter(base.BaseFunctionalTest): class TestMeter(base.BaseFunctionalTest):
def setUp(self):
super(TestMeter, self).setUp()
self.require_service('metering')
def test_list(self): def test_list(self):
# TODO(thowe): Remove this in favor of create_meter call. # TODO(thowe): Remove this in favor of create_meter call.
# Since we do not have a create meter method at the moment # Since we do not have a create meter method at the moment
# make sure there is some data in there # make sure there is some data in there
name = uuid.uuid4().hex name = self.getUniqueString()
tainer = self.conn.object_store.create_container(name=name) tainer = self.conn.object_store.create_container(name=name)
self.conn.object_store.delete_container(tainer) self.conn.object_store.delete_container(tainer)

8
openstack/tests/functional/telemetry/v2/test_resource.py
View File

@@ -10,15 +10,15 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import unittest
from openstack.tests.functional import base from openstack.tests.functional import base
@unittest.skipUnless(base.service_exists(service_type="metering"),
"Metering service does not exist")
class TestResource(base.BaseFunctionalTest): class TestResource(base.BaseFunctionalTest):
def setUp(self):
super(TestResource, self).setUp()
self.require_service('metering')
def test_list(self): def test_list(self):
ids = [o.resource_id for o in self.conn.telemetry.resources()] ids = [o.resource_id for o in self.conn.telemetry.resources()]
self.assertNotEqual(0, len(ids)) self.assertNotEqual(0, len(ids))

8
openstack/tests/functional/telemetry/v2/test_sample.py
View File

@@ -10,16 +10,16 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import unittest
from openstack.telemetry.v2 import sample from openstack.telemetry.v2 import sample
from openstack.tests.functional import base from openstack.tests.functional import base
@unittest.skipUnless(base.service_exists(service_type="metering"),
"Metering service does not exist")
class TestSample(base.BaseFunctionalTest): class TestSample(base.BaseFunctionalTest):
def setUp(self):
super(TestSample, self).setUp()
self.require_service('metering')
def test_list(self): def test_list(self):
for meter in self.conn.telemetry.meters(): for meter in self.conn.telemetry.meters():
for sot in self.conn.telemetry.samples(meter): for sot in self.conn.telemetry.samples(meter):

8
openstack/tests/functional/telemetry/v2/test_statistics.py
View File

@@ -10,15 +10,15 @@
# License for the specific language governing permissions and limitations # License for the specific language governing permissions and limitations
# under the License. # under the License.
import unittest
from openstack.tests.functional import base from openstack.tests.functional import base
@unittest.skipUnless(base.service_exists(service_type="metering"),
"Metering service does not exist")
class TestStatistics(base.BaseFunctionalTest): class TestStatistics(base.BaseFunctionalTest):
def setUp(self):
super(TestStatistics, self).setUp()
self.require_service('metering')
def test_list(self): def test_list(self):
for met in self.conn.telemetry.meters(): for met in self.conn.telemetry.meters():
for stat in self.conn.telemetry.statistics(met): for stat in self.conn.telemetry.statistics(met):