openstack
/
tempest
Code Issues Proposed changes

Optimized and reduced the scope of smoke tests 

* Factored images smoke test into seperate class
* Removed any tests from smoke that are extensions
* Moved list servers smoke tests into part of general server creation smoke test
* Overall smoke test execution time reduced by 50%

Change-Id: I4838cea39d3338033fd2d4400d9622b55c38ff3c
This commit is contained in:
Daryl Walleck 2012-07-04 23:25:45 -05:00
parent edba0620c4
commit ed97dcabd0
10 changed files with 294 additions and 260 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
tempest/tests/compute/__init__.py
View File

@ -31,6 +31,7 @@ DISK_CONFIG_ENABLED = False
FLAVOR_EXTRA_DATA_ENABLED = False
MULTI_USER = False
# All compute tests -- single setup function
def setup_package():
LOG.debug("Entering tempest.tests.compute.setup_package")

18
tempest/tests/compute/test_create_server.py
View File

@ -65,7 +65,7 @@ class ServersTest(BaseComputeTest):
self.assertTrue(self.server_initial['adminPass'] is not None)
@attr(type='smoke')
def test_created_server_fields(self):
def test_verify_server_details(self):
"""Verify the specified server attributes are set correctly"""
self.assertEqual(self.accessIPv4, self.server['accessIPv4'])
@ -75,6 +75,22 @@ class ServersTest(BaseComputeTest):
self.assertEqual(str(self.flavor_ref), self.server['flavor']['id'])
self.assertEqual(self.meta, self.server['metadata'])
@attr(type='smoke')
def test_list_servers(self):
"""The created server should be in the list of all servers"""
resp, body = self.client.list_servers()
servers = body['servers']
found = any([i for i in servers if i['id'] == self.server['id']])
self.assertTrue(found)
@attr(type='smoke')
def test_list_servers_with_detail(self):
"""The created server should be in the detailed list of all servers"""
resp, body = self.client.list_servers_with_detail()
servers = body['servers']
found = any([i for i in servers if i['id'] == self.server['id']])
self.assertTrue(found)
@attr(type='positive')
@unittest.skipIf(not run_ssh, 'Instance validation tests are disabled.')
def test_can_log_into_created_server(self):

2
tempest/tests/compute/test_extensions.py
View File

@ -27,7 +27,7 @@ class ExtensionsTest(BaseComputeTest):
super(ExtensionsTest, cls).setUpClass()
cls.client = cls.extensions_client
@attr(type='smoke')
@attr(type='positive')
def test_list_extensions(self):
"""List of all extensions"""
resp, extensions = self.client.list_extensions()

8
tempest/tests/compute/test_keypairs.py
View File

@ -30,7 +30,7 @@ class KeyPairsTest(BaseComputeTest):
super(KeyPairsTest, cls).setUpClass()
cls.client = cls.keypairs_client
@attr(type='smoke')
@attr(type='positive')
def test_keypairs_create_list_delete(self):
"""Keypairs created should be available in the response list"""
#Create 3 keypairs
@ -64,7 +64,7 @@ class KeyPairsTest(BaseComputeTest):
resp, _ = self.client.delete_keypair(keypair['name'])
self.assertEqual(202, resp.status)
@attr(type='smoke')
@attr(type='positive')
def test_keypair_create_delete(self):
"""Keypair should be created, verified and deleted"""
k_name = rand_name('keypair-')
@ -79,7 +79,7 @@ class KeyPairsTest(BaseComputeTest):
resp, _ = self.client.delete_keypair(k_name)
self.assertEqual(202, resp.status)
@attr(type='smoke')
@attr(type='positive')
@unittest.skip("Skipped until the Bug #980688 is resolved")
def test_get_keypair_detail(self):
"""Keypair should be created, Got details by name and deleted"""
@ -102,7 +102,7 @@ class KeyPairsTest(BaseComputeTest):
resp, _ = self.client.delete_keypair(k_name)
self.assertEqual(202, resp.status)
@attr(type='smoke')
@attr(type='positive')
def test_keypair_create_with_pub_key(self):
"""Keypair should be created with a given public key"""
k_name = rand_name('keypair-')

248
tempest/tests/compute/test_list_image_filters.py Normal file
View File

@ -0,0 +1,248 @@
# vim: tabstop=4 shiftwidth=4 softtabstop=4
# Copyright 2012 OpenStack, LLC
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from nose.plugins.attrib import attr
from tempest import exceptions
from tempest.common.utils.data_utils import rand_name, parse_image_id
from tempest.tests.compute.base import BaseComputeTest
class ListImageFiltersTest(BaseComputeTest):
@classmethod
def setUpClass(cls):
super(ListImageFiltersTest, cls).setUpClass()
cls.client = cls.images_client
name = rand_name('server')
resp, cls.server1 = cls.servers_client.create_server(name,
cls.image_ref,
cls.flavor_ref)
name = rand_name('server')
resp, cls.server2 = cls.servers_client.create_server(name,
cls.image_ref,
cls.flavor_ref)
cls.servers_client.wait_for_server_status(cls.server1['id'], 'ACTIVE')
cls.servers_client.wait_for_server_status(cls.server2['id'], 'ACTIVE')
# Create images to be used in the filter tests
image1_name = rand_name('image')
resp, body = cls.client.create_image(cls.server1['id'], image1_name)
cls.image1_id = parse_image_id(resp['location'])
cls.client.wait_for_image_resp_code(cls.image1_id, 200)
cls.client.wait_for_image_status(cls.image1_id, 'ACTIVE')
resp, cls.image1 = cls.client.get_image(cls.image1_id)
# Servers have a hidden property for when they are being imaged
# Performing back-to-back create image calls on a single
# server will sometimes cause failures
image3_name = rand_name('image')
resp, body = cls.client.create_image(cls.server2['id'], image3_name)
cls.image3_id = parse_image_id(resp['location'])
cls.client.wait_for_image_resp_code(cls.image3_id, 200)
cls.client.wait_for_image_status(cls.image3_id, 'ACTIVE')
resp, cls.image3 = cls.client.get_image(cls.image3_id)
image2_name = rand_name('image')
resp, body = cls.client.create_image(cls.server1['id'], image2_name)
cls.image2_id = parse_image_id(resp['location'])
cls.client.wait_for_image_resp_code(cls.image2_id, 200)
cls.client.wait_for_image_status(cls.image2_id, 'ACTIVE')
resp, cls.image2 = cls.client.get_image(cls.image2_id)
@classmethod
def tearDownClass(cls):
cls.client.delete_image(cls.image1_id)
cls.client.delete_image(cls.image2_id)
cls.client.delete_image(cls.image3_id)
cls.servers_client.delete_server(cls.server1['id'])
cls.servers_client.delete_server(cls.server2['id'])
super(ListImagesTest, cls).tearDownClass()
@attr(type='negative')
def test_get_image_not_existing(self):
"""Check raises a NotFound"""
self.assertRaises(exceptions.NotFound, self.client.get_image,
"nonexistingimageid")
@attr(type='positive')
def test_list_images_filter_by_status(self):
"""
The list of images should contain only images with the provided status
"""
params = {'status': 'ACTIVE'}
resp, images = self.client.list_images(params)
self.assertTrue(any([i for i in images if i['id'] == self.image1_id]))
self.assertTrue(any([i for i in images if i['id'] == self.image2_id]))
self.assertTrue(any([i for i in images if i['id'] == self.image3_id]))
@attr(type='positive')
def test_list_images_filter_by_name(self):
"""
List of all images should contain the expected images filtered by name
"""
params = {'name': self.image1['name']}
resp, images = self.client.list_images(params)
self.assertTrue(any([i for i in images if i['id'] == self.image1_id]))
self.assertFalse(any([i for i in images if i['id'] == self.image2_id]))
self.assertFalse(any([i for i in images if i['id'] == self.image3_id]))
@attr(type='positive')
def test_list_images_filter_by_server_id(self):
"""The images should contain images filtered by server id"""
params = {'server': self.server1['id']}
resp, images = self.client.list_images(params)
self.assertTrue(any([i for i in images if i['id'] == self.image1_id]),
"Failed to find image %s in images. Got images %s" %
(self.image1_id, images))
self.assertTrue(any([i for i in images if i['id'] == self.image2_id]))
self.assertFalse(any([i for i in images if i['id'] == self.image3_id]))
@attr(type='positive')
def test_list_images_filter_by_server_ref(self):
"""The list of servers should be filtered by server ref"""
server_links = self.server2['links']
# Try all server link types
for link in server_links:
params = {'server': link['href']}
resp, images = self.client.list_images(params)
self.assertFalse(any([i for i in images
if i['id'] == self.image1_id]))
self.assertFalse(any([i for i in images
if i['id'] == self.image2_id]))
self.assertTrue(any([i for i in images
if i['id'] == self.image3_id]))
@attr(type='positive')
def test_list_images_filter_by_type(self):
"""The list of servers should be filtered by image type"""
params = {'type': 'snapshot'}
resp, images = self.client.list_images(params)
self.assertTrue(any([i for i in images if i['id'] == self.image1_id]))
self.assertTrue(any([i for i in images if i['id'] == self.image2_id]))
self.assertTrue(any([i for i in images if i['id'] == self.image3_id]))
self.assertFalse(any([i for i in images if i['id'] == self.image_ref]))
@attr(type='positive')
def test_list_images_limit_results(self):
"""Verify only the expected number of results are returned"""
params = {'limit': '1'}
resp, images = self.client.list_images(params)
self.assertEqual(1, len(images))
@attr(type='positive')
def test_list_images_filter_by_changes_since(self):
"""Verify only updated images are returned in the detailed list"""
#Becoming ACTIVE will modify the updated time
#Filter by the image's created time
params = {'changes-since': self.image3['created']}
resp, images = self.client.list_images(params)
found = any([i for i in images if i['id'] == self.image3_id])
self.assertTrue(found)
@attr(type='positive')
def test_list_images_with_detail_filter_by_status(self):
"""
Detailed list of all images should only contain images
with the provided status
"""
params = {'status': 'ACTIVE'}
resp, images = self.client.list_images_with_detail(params)
self.assertTrue(any([i for i in images if i['id'] == self.image1_id]))
self.assertTrue(any([i for i in images if i['id'] == self.image2_id]))
self.assertTrue(any([i for i in images if i['id'] == self.image3_id]))
@attr(type='positive')
def test_list_images_with_detail_filter_by_name(self):
"""
Detailed list of all images should contain the expected
images filtered by name
"""
params = {'name': self.image1['name']}
resp, images = self.client.list_images_with_detail(params)
self.assertTrue(any([i for i in images if i['id'] == self.image1_id]))
self.assertFalse(any([i for i in images if i['id'] == self.image2_id]))
self.assertFalse(any([i for i in images if i['id'] == self.image3_id]))
@attr(type='positive')
def test_list_images_with_detail_limit_results(self):
"""
Verify only the expected number of results (with full details)
are returned
"""
params = {'limit': '1'}
resp, images = self.client.list_images_with_detail(params)
self.assertEqual(1, len(images))
@attr(type='positive')
def test_list_images_with_detail_filter_by_server_ref(self):
"""Detailed list of servers should be filtered by server ref"""
server_links = self.server2['links']
# Try all server link types
for link in server_links:
params = {'server': link['href']}
resp, images = self.client.list_images_with_detail(params)
self.assertFalse(any([i for i in images
if i['id'] == self.image1_id]))
self.assertFalse(any([i for i in images
if i['id'] == self.image2_id]))
self.assertTrue(any([i for i in images
if i['id'] == self.image3_id]))
@attr(type='positive')
def test_list_images_with_detail_filter_by_type(self):
"""The detailed list of servers should be filtered by image type"""
params = {'type': 'snapshot'}
resp, images = self.client.list_images_with_detail(params)
resp, image4 = self.client.get_image(self.image_ref)
self.assertTrue(any([i for i in images if i['id'] == self.image1_id]))
self.assertTrue(any([i for i in images if i['id'] == self.image2_id]))
self.assertTrue(any([i for i in images if i['id'] == self.image3_id]))
self.assertFalse(any([i for i in images if i['id'] == self.image_ref]))
@attr(type='positive')
def test_list_images_with_detail_filter_by_changes_since(self):
"""Verify an update image is returned"""
#Becoming ACTIVE will modify the updated time
#Filter by the image's created time
params = {'changes-since': self.image1['created']}
resp, images = self.client.list_images_with_detail(params)
self.assertTrue(any([i for i in images if i['id'] == self.image1_id]))
@attr(type='negative')
def test_get_nonexistant_image(self):
"""Negative test: GET on non existant image should fail"""
try:
resp, image = self.client.get_image(999)
except:
pass
else:
self.fail('GET on non existant image should fail')

220
tempest/tests/compute/test_list_images.py
View File

@ -29,49 +29,8 @@ class ListImagesTest(BaseComputeTest):
super(ListImagesTest, cls).setUpClass()
cls.client = cls.images_client
name = rand_name('server')
resp, cls.server1 = cls.servers_client.create_server(name,
cls.image_ref,
cls.flavor_ref)
name = rand_name('server')
resp, cls.server2 = cls.servers_client.create_server(name,
cls.image_ref,
cls.flavor_ref)
cls.servers_client.wait_for_server_status(cls.server1['id'], 'ACTIVE')
cls.servers_client.wait_for_server_status(cls.server2['id'], 'ACTIVE')
# Create images to be used in the filter tests
image1_name = rand_name('image')
resp, body = cls.client.create_image(cls.server1['id'], image1_name)
cls.image1_id = parse_image_id(resp['location'])
cls.client.wait_for_image_resp_code(cls.image1_id, 200)
cls.client.wait_for_image_status(cls.image1_id, 'ACTIVE')
resp, cls.image1 = cls.client.get_image(cls.image1_id)
# Servers have a hidden property for when they are being imaged
# Performing back-to-back create image calls on a single
# server will sometimes cause failures
image3_name = rand_name('image')
resp, body = cls.client.create_image(cls.server2['id'], image3_name)
cls.image3_id = parse_image_id(resp['location'])
cls.client.wait_for_image_resp_code(cls.image3_id, 200)
cls.client.wait_for_image_status(cls.image3_id, 'ACTIVE')
resp, cls.image3 = cls.client.get_image(cls.image3_id)
image2_name = rand_name('image')
resp, body = cls.client.create_image(cls.server1['id'], image2_name)
cls.image2_id = parse_image_id(resp['location'])
cls.client.wait_for_image_resp_code(cls.image2_id, 200)
cls.client.wait_for_image_status(cls.image2_id, 'ACTIVE')
resp, cls.image2 = cls.client.get_image(cls.image2_id)
@classmethod
def tearDownClass(cls):
cls.client.delete_image(cls.image1_id)
cls.client.delete_image(cls.image2_id)
cls.client.delete_image(cls.image3_id)
cls.servers_client.delete_server(cls.server1['id'])
cls.servers_client.delete_server(cls.server2['id'])
super(ListImagesTest, cls).tearDownClass()
@attr(type='smoke')
@ -80,12 +39,6 @@ class ListImagesTest(BaseComputeTest):
resp, image = self.client.get_image(self.image_ref)
self.assertEqual(self.image_ref, image['id'])
@attr(type='negative')
def test_get_image_not_existing(self):
"""Check raises a NotFound"""
self.assertRaises(exceptions.NotFound, self.client.get_image,
"nonexistingimageid")
@attr(type='smoke')
def test_list_images(self):
"""The list of all images should contain the image"""
@ -93,178 +46,9 @@ class ListImagesTest(BaseComputeTest):
found = any([i for i in images if i['id'] == self.image_ref])
self.assertTrue(found)
@attr(type='positive')
def test_list_images_filter_by_status(self):
"""
The list of images should contain only images with the provided status
"""
params = {'status': 'ACTIVE'}
resp, images = self.client.list_images(params)
self.assertTrue(any([i for i in images if i['id'] == self.image1_id]))
self.assertTrue(any([i for i in images if i['id'] == self.image2_id]))
self.assertTrue(any([i for i in images if i['id'] == self.image3_id]))
@attr(type='positive')
def test_list_images_filter_by_name(self):
"""
List of all images should contain the expected images filtered by name
"""
params = {'name': self.image1['name']}
resp, images = self.client.list_images(params)
self.assertTrue(any([i for i in images if i['id'] == self.image1_id]))
self.assertFalse(any([i for i in images if i['id'] == self.image2_id]))
self.assertFalse(any([i for i in images if i['id'] == self.image3_id]))
@attr(type='positive')
def test_list_images_filter_by_server_id(self):
"""The images should contain images filtered by server id"""
params = {'server': self.server1['id']}
resp, images = self.client.list_images(params)
self.assertTrue(any([i for i in images if i['id'] == self.image1_id]),
"Failed to find image %s in images. Got images %s" %
(self.image1_id, images))
self.assertTrue(any([i for i in images if i['id'] == self.image2_id]))
self.assertFalse(any([i for i in images if i['id'] == self.image3_id]))
@attr(type='positive')
def test_list_images_filter_by_server_ref(self):
"""The list of servers should be filtered by server ref"""
server_links = self.server2['links']
# Try all server link types
for link in server_links:
params = {'server': link['href']}
resp, images = self.client.list_images(params)
self.assertFalse(any([i for i in images
if i['id'] == self.image1_id]))
self.assertFalse(any([i for i in images
if i['id'] == self.image2_id]))
self.assertTrue(any([i for i in images
if i['id'] == self.image3_id]))
@attr(type='positive')
def test_list_images_filter_by_type(self):
"""The list of servers should be filtered by image type"""
params = {'type': 'snapshot'}
resp, images = self.client.list_images(params)
self.assertTrue(any([i for i in images if i['id'] == self.image1_id]))
self.assertTrue(any([i for i in images if i['id'] == self.image2_id]))
self.assertTrue(any([i for i in images if i['id'] == self.image3_id]))
self.assertFalse(any([i for i in images if i['id'] == self.image_ref]))
@attr(type='positive')
def test_list_images_limit_results(self):
"""Verify only the expected number of results are returned"""
params = {'limit': '1'}
resp, images = self.client.list_images(params)
self.assertEqual(1, len(images))
@attr(type='positive')
def test_list_images_filter_by_changes_since(self):
"""Verify only updated images are returned in the detailed list"""
#Becoming ACTIVE will modify the updated time
#Filter by the image's created time
params = {'changes-since': self.image3['created']}
resp, images = self.client.list_images(params)
found = any([i for i in images if i['id'] == self.image3_id])
self.assertTrue(found)
@attr(type='smoke')
def test_list_images_with_detail(self):
"""Detailed list of all images should contain the expected images"""
resp, images = self.client.list_images_with_detail()
self.assertTrue(any([i for i in images if i['id'] == self.image1_id]))
self.assertTrue(any([i for i in images if i['id'] == self.image2_id]))
self.assertTrue(any([i for i in images if i['id'] == self.image3_id]))
@attr(type='positive')
def test_list_images_with_detail_filter_by_status(self):
"""
Detailed list of all images should only contain images
with the provided status
"""
params = {'status': 'ACTIVE'}
resp, images = self.client.list_images_with_detail(params)
self.assertTrue(any([i for i in images if i['id'] == self.image1_id]))
self.assertTrue(any([i for i in images if i['id'] == self.image2_id]))
self.assertTrue(any([i for i in images if i['id'] == self.image3_id]))
@attr(type='positive')
def test_list_images_with_detail_filter_by_name(self):
"""
Detailed list of all images should contain the expected
images filtered by name
"""
params = {'name': self.image1['name']}
resp, images = self.client.list_images_with_detail(params)
self.assertTrue(any([i for i in images if i['id'] == self.image1_id]))
self.assertFalse(any([i for i in images if i['id'] == self.image2_id]))
self.assertFalse(any([i for i in images if i['id'] == self.image3_id]))
@attr(type='positive')
def test_list_images_with_detail_limit_results(self):
"""
Verify only the expected number of results (with full details)
are returned
"""
params = {'limit': '1'}
resp, images = self.client.list_images_with_detail(params)
self.assertEqual(1, len(images))
@attr(type='positive')
def test_list_images_with_detail_filter_by_server_ref(self):
"""Detailed list of servers should be filtered by server ref"""
server_links = self.server2['links']
# Try all server link types
for link in server_links:
params = {'server': link['href']}
resp, images = self.client.list_images_with_detail(params)
self.assertFalse(any([i for i in images
if i['id'] == self.image1_id]))
self.assertFalse(any([i for i in images
if i['id'] == self.image2_id]))
self.assertTrue(any([i for i in images
if i['id'] == self.image3_id]))
@attr(type='positive')
def test_list_images_with_detail_filter_by_type(self):
"""The detailed list of servers should be filtered by image type"""
params = {'type': 'snapshot'}
resp, images = self.client.list_images_with_detail(params)
resp, image4 = self.client.get_image(self.image_ref)
self.assertTrue(any([i for i in images if i['id'] == self.image1_id]))
self.assertTrue(any([i for i in images if i['id'] == self.image2_id]))
self.assertTrue(any([i for i in images if i['id'] == self.image3_id]))
self.assertFalse(any([i for i in images if i['id'] == self.image_ref]))
@attr(type='positive')
def test_list_images_with_detail_filter_by_changes_since(self):
"""Verify an update image is returned"""
#Becoming ACTIVE will modify the updated time
#Filter by the image's created time
params = {'changes-since': self.image1['created']}
resp, images = self.client.list_images_with_detail(params)
self.assertTrue(any([i for i in images if i['id'] == self.image1_id]))
@attr(type='negative')
def test_get_nonexistant_image(self):
"""Negative test: GET on non existant image should fail"""
try:
resp, image = self.client.get_image(999)
except:
pass
else:
self.fail('GET on non existant image should fail')
found = any([i for i in images if i['id'] == self.image_ref])
self.assertTrue(found)

43
tempest/tests/compute/test_list_servers.py → tempest/tests/compute/test_list_server_filters.py
View File

@ -16,6 +16,7 @@
# under the License.
import nose.plugins.skip
from nose.plugins.attrib import attr
import unittest2 as unittest
from tempest import exceptions
@ -24,11 +25,11 @@ from tempest.tests.compute.base import BaseComputeTest
from tempest.tests import utils
class ServerDetailsTest(BaseComputeTest):
class ListServerFiltersTest(BaseComputeTest):
@classmethod
def setUpClass(cls):
super(ServerDetailsTest, cls).setUpClass()
super(ListServerFiltersTest, cls).setUpClass()
cls.client = cls.servers_client
# Check to see if the alternate image ref actually exists...
@ -84,18 +85,10 @@ class ServerDetailsTest(BaseComputeTest):
cls.client.delete_server(cls.s1['id'])
cls.client.delete_server(cls.s2['id'])
cls.client.delete_server(cls.s3['id'])
super(ServerDetailsTest, cls).tearDownClass()
def test_list_servers(self):
"""Return a list of all servers"""
resp, body = self.client.list_servers()
servers = body['servers']
self.assertTrue(self.s1_min in servers)
self.assertTrue(self.s2_min in servers)
self.assertTrue(self.s3_min in servers)
super(ListServerFiltersTest, cls).tearDownClass()
@utils.skip_unless_attr('multiple_images', 'Only one image found')
@attr(type='positive')
def test_list_servers_filter_by_image(self):
"""Filter the list of servers by image"""
params = {'image': self.image_ref}
@ -106,6 +99,7 @@ class ServerDetailsTest(BaseComputeTest):
self.assertTrue(self.s2_min not in servers)
self.assertTrue(self.s3_min in servers)
@attr(type='positive')
def test_list_servers_filter_by_flavor(self):
"""Filter the list of servers by flavor"""
params = {'flavor': self.flavor_ref_alt}
@ -116,6 +110,7 @@ class ServerDetailsTest(BaseComputeTest):
self.assertTrue(self.s2_min not in servers)
self.assertTrue(self.s3_min in servers)
@attr(type='positive')
def test_list_servers_filter_by_server_name(self):
"""Filter the list of servers by server name"""
params = {'name': self.s1_name}
@ -126,6 +121,7 @@ class ServerDetailsTest(BaseComputeTest):
self.assertTrue(self.s2_min not in servers)
self.assertTrue(self.s3_min not in servers)
@attr(type='positive')
def test_list_servers_filter_by_server_status(self):
"""Filter the list of servers by server status"""
params = {'status': 'active'}
@ -136,22 +132,15 @@ class ServerDetailsTest(BaseComputeTest):
self.assertTrue(self.s2_min in servers)
self.assertTrue(self.s3_min in servers)
@attr(type='positive')
def test_list_servers_limit_results(self):
"""Verify only the expected number of servers are returned"""
params = {'limit': 1}
resp, servers = self.client.list_servers_with_detail(params)
self.assertEqual(1, len(servers['servers']))
def test_list_servers_with_detail(self):
""" Return a detailed list of all servers """
resp, body = self.client.list_servers_with_detail()
servers = body['servers']
self.assertTrue(self.s1 in servers)
self.assertTrue(self.s2 in servers)
self.assertTrue(self.s3 in servers)
@utils.skip_unless_attr('multiple_images', 'Only one image found')
@attr(type='positive')
def test_list_servers_detailed_filter_by_image(self):
"""Filter the detailed list of servers by image"""
params = {'image': self.image_ref}
@ -162,6 +151,7 @@ class ServerDetailsTest(BaseComputeTest):
self.assertTrue(self.s2 not in servers)
self.assertTrue(self.s3 in servers)
@attr(type='positive')
def test_list_servers_detailed_filter_by_flavor(self):
"""Filter the detailed list of servers by flavor"""
params = {'flavor': self.flavor_ref_alt}
@ -172,6 +162,7 @@ class ServerDetailsTest(BaseComputeTest):
self.assertTrue(self.s2 not in servers)
self.assertTrue(self.s3 in servers)
@attr(type='positive')
def test_list_servers_detailed_filter_by_server_name(self):
"""Filter the detailed list of servers by server name"""
params = {'name': self.s1_name}
@ -182,6 +173,7 @@ class ServerDetailsTest(BaseComputeTest):
self.assertTrue(self.s2 not in servers)
self.assertTrue(self.s3 not in servers)
@attr(type='positive')
def test_list_servers_detailed_filter_by_server_status(self):
"""Filter the detailed list of servers by server status"""
params = {'status': 'active'}
@ -192,20 +184,13 @@ class ServerDetailsTest(BaseComputeTest):
self.assertTrue(self.s2 in servers)
self.assertTrue(self.s3 in servers)
@attr(type='positive')
def test_list_servers_detailed_limit_results(self):
"""Verify only the expected number of detailed results are returned"""
params = {'limit': 1}
resp, servers = self.client.list_servers_with_detail(params)
self.assertEqual(1, len(servers['servers']))
def test_get_server_details(self):
"""Return the full details of a single server"""
resp, server = self.client.get_server(self.s1['id'])
self.assertEqual(self.s1_name, server['name'])
self.assertEqual(self.image_ref, server['image']['id'])
self.assertEqual(str(self.flavor_ref), server['flavor']['id'])
@classmethod
def _convert_to_min_details(self, server):
min_detail = {}

4
tempest/tests/compute/test_security_groups.py
View File

@ -60,7 +60,7 @@ class SecurityGroupsTest(BaseComputeTest):
self.client.delete_security_group(securitygroup['id'])
self.assertEqual(202, resp.status)
@attr(type='smoke')
@attr(type='positive')
def test_security_group_create_delete(self):
"""Security Group should be created, verified and deleted"""
try:
@ -82,7 +82,7 @@ class SecurityGroupsTest(BaseComputeTest):
resp, _ = self.client.delete_security_group(securitygroup['id'])
self.assertEqual(202, resp.status)
@attr(type='smoke')
@attr(type='positive')
def test_security_group_create_get_delete(self):
"""Security Group should be created, fetched and deleted"""
try:

2
tempest/tests/compute/test_server_actions.py
View File

@ -116,7 +116,7 @@ class ServerActionsTest(BaseComputeTest):
resp, server = self.client.get_server(self.server_id)
self.assertEqual(self.flavor_ref_alt, server['flavor']['id'])
@attr(type='smoke')
@attr(type='positive')
@unittest.skipIf(not resize_available, 'Resize not available.')
def test_resize_server_revert(self):
"""

8
tempest/tests/compute/test_servers.py
View File

@ -28,7 +28,7 @@ class ServersTest(BaseComputeTest):
super(ServersTest, cls).setUpClass()
cls.client = cls.servers_client
@attr(type='smoke')
@attr(type='positive')
def test_create_server_with_admin_password(self):
"""
If an admin password is provided on server creation, the server's root
@ -74,7 +74,7 @@ class ServersTest(BaseComputeTest):
if server_id:
self.client.delete_server(server_id)
@attr(type='smoke')
@attr(type='positive')
def test_create_specify_keypair(self):
"""Specify a keypair while creating a server"""
@ -95,7 +95,7 @@ class ServersTest(BaseComputeTest):
if server:
self.client.delete_server(server['id'])
@attr(type='smoke')
@attr(type='positive')
def test_update_server_name(self):
"""The server name should be changed to the the provided value"""
try:
@ -118,7 +118,7 @@ class ServersTest(BaseComputeTest):
finally:
self.client.delete_server(server['id'])
@attr(type='smoke')
@attr(type='positive')
def test_update_access_server_address(self):
"""
The server's access addresses should reflect the provided values