openstack
/
trove
Code Issues Proposed changes

Break apart instance create/actions scenario tests 

The instance create and actions scenario tests were broken
into separate parts to facilitate parallel runs in the gate.

Change-Id: Ieeee9bcfe588c0f7ef80cb95eda33059d0486813
Partial-Bug: #1571092
This commit is contained in:
Peter Stachowski 2016-05-30 22:57:20 -04:00
parent 9147f9dd6b
commit 1273b27d60
4 changed files with 96 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
trove/tests/scenario/groups/instance_actions_group.py
View File

@ -21,6 +21,8 @@ from trove.tests.scenario.runners import test_runners
GROUP = "scenario.instance_actions_group"
GROUP_INST_ACTIONS = "scenario.inst_actions_group"
GROUP_INST_ACTIONS_WAIT = "scenario.inst_actions_wait_group"
class InstanceActionsRunnerFactory(test_runners.RunnerFactory):
@ -29,8 +31,10 @@ class InstanceActionsRunnerFactory(test_runners.RunnerFactory):
_runner_cls = 'InstanceActionsRunner'
@test(depends_on_groups=[instance_create_group.GROUP], groups=[GROUP])
@test(depends_on_groups=[instance_create_group.GROUP],
groups=[GROUP, GROUP_INST_ACTIONS])
class InstanceActionsGroup(TestGroup):
"""Test Instance Actions functionality."""
def __init__(self):
super(InstanceActionsGroup, self).__init__(
@ -50,3 +54,18 @@ class InstanceActionsGroup(TestGroup):
def instance_resize_flavor(self):
"""Resize instance flavor."""
self.test_runner.run_instance_resize_flavor()
@test(depends_on_groups=[GROUP_INST_ACTIONS],
groups=[GROUP, GROUP_INST_ACTIONS_WAIT])
class InstanceActionsWaitGroup(TestGroup):
"""Test that Instance Actions Completes."""
def __init__(self):
super(InstanceActionsWaitGroup, self).__init__(
InstanceActionsRunnerFactory.instance())
@test
def wait_for_instance_resize_flavor(self):
"""Wait for resize instance flavor to complete."""
self.test_runner.run_wait_for_instance_resize_flavor()

53
trove/tests/scenario/groups/instance_create_group.py
View File

@ -21,6 +21,10 @@ from trove.tests.scenario.runners import test_runners
GROUP = "scenario.instance_create_group"
GROUP_INST_CREATE = "scenario.inst_create_group"
GROUP_INST_CREATE_WAIT = "scenario.inst_create_wait_group"
GROUP_INIT_INST_DELETE = "scenario.init_inst_delete_group"
GROUP_INIT_INST_DELETE_WAIT = "scenario.init_inst_delete_wait_group"
class InstanceCreateRunnerFactory(test_runners.RunnerFactory):
@ -29,10 +33,11 @@ class InstanceCreateRunnerFactory(test_runners.RunnerFactory):
_runner_cls = 'InstanceCreateRunner'
@test(groups=[GROUP],
depends_on_groups=["services.initialize"],
runs_after_groups=[PRE_INSTANCES])
@test(depends_on_groups=["services.initialize"],
runs_after_groups=[PRE_INSTANCES],
groups=[GROUP, GROUP_INST_CREATE])
class InstanceCreateGroup(TestGroup):
"""Test Instance Create functionality."""
def __init__(self):
super(InstanceCreateGroup, self).__init__(
@ -53,7 +58,17 @@ class InstanceCreateGroup(TestGroup):
"""Create an instance with initial properties."""
self.test_runner.run_initialized_instance_create()
@test(runs_after=[create_initialized_instance])
@test(depends_on_groups=[GROUP_INST_CREATE],
groups=[GROUP, GROUP_INST_CREATE_WAIT])
class InstanceCreateWaitGroup(TestGroup):
"""Test that Instance Create Completes."""
def __init__(self):
super(InstanceCreateWaitGroup, self).__init__(
InstanceCreateRunnerFactory.instance())
@test
def wait_for_instances(self):
"""Waiting for all instances to become active."""
self.test_runner.wait_for_created_instances()
@ -68,13 +83,37 @@ class InstanceCreateGroup(TestGroup):
"""Validate the initialized instance data and properties."""
self.test_runner.run_validate_initialized_instance()
@test(runs_after=[validate_initialized_instance])
@test(depends_on_groups=[GROUP_INST_CREATE_WAIT],
groups=[GROUP, GROUP_INIT_INST_DELETE])
class InstanceInitDeleteGroup(TestGroup):
"""Test Initialized Instance Delete functionality."""
def __init__(self):
super(InstanceInitDeleteGroup, self).__init__(
InstanceCreateRunnerFactory.instance())
@test
def delete_initialized_instance(self):
"""Delete the initialized instance."""
self.test_runner.run_initialized_instance_delete()
@test(depends_on=[create_initial_configuration,
delete_initialized_instance])
@test(depends_on_groups=[GROUP_INIT_INST_DELETE],
groups=[GROUP, GROUP_INIT_INST_DELETE_WAIT])
class InstanceInitDeleteWaitGroup(TestGroup):
"""Test that Initialized Instance Delete Completes."""
def __init__(self):
super(InstanceInitDeleteWaitGroup, self).__init__(
InstanceCreateRunnerFactory.instance())
@test
def wait_for_initialized_instance_delete(self):
"""Wait for the initialized instance to be deleted."""
self.test_runner.run_wait_for_initialized_instance_delete()
@test(runs_after=[wait_for_initialized_instance_delete])
def delete_initial_configuration(self):
"""Delete the initial configuration group."""
self.test_runner.run_initial_configuration_delete()

46
trove/tests/scenario/runners/instance_actions_runners.py
View File

@ -24,6 +24,8 @@ class InstanceActionsRunner(TestRunner):
def __init__(self):
super(InstanceActionsRunner, self).__init__()
self.resize_flavor_id = self._get_resize_flavor().id
def _get_resize_flavor(self):
if self.EPHEMERAL_SUPPORT:
flavor_name = CONFIG.values.get(
@ -53,10 +55,9 @@ class InstanceActionsRunner(TestRunner):
expected_states=['RESIZE', 'ACTIVE'],
expected_http_code=202):
if self.VOLUME_SUPPORT:
self.assert_instance_resize_volume(self.instance_info.id,
resize_amount,
expected_states,
expected_http_code)
self.assert_instance_resize_volume(
self.instance_info.id, resize_amount, expected_states,
expected_http_code)
else:
raise SkipTest("Volume support is disabled.")
@ -74,27 +75,26 @@ class InstanceActionsRunner(TestRunner):
expected_http_code)
instance = self.get_instance(instance_id)
self.assert_equal(instance.volume['size'], new_volume_size,
self.assert_equal(new_volume_size, instance.volume['size'],
'Unexpected new volume size')
def run_instance_resize_flavor(
self, expected_states=['RESIZE', 'ACTIVE'],
expected_http_code=202):
resize_flavor = self._get_resize_flavor()
self.assert_instance_resize_flavor(self.instance_info.id,
resize_flavor, expected_states,
expected_http_code)
def run_instance_resize_flavor(self, expected_http_code=202):
self.assert_instance_resize_flavor(
self.instance_info.id, self.resize_flavor_id, expected_http_code)
def assert_instance_resize_flavor(self, instance_id, resize_flavor,
expected_states, expected_http_code):
self.report.log("Testing resize to '%s' on instance: %s"
% (resize_flavor, instance_id))
def assert_instance_resize_flavor(self, instance_id, resize_flavor_id,
expected_http_code):
self.report.log("Testing resize to '%s' on instance: %s" %
(resize_flavor_id, instance_id))
self.auth_client.instances.resize_instance(
instance_id, resize_flavor_id)
self.assert_client_code(expected_http_code)
self.auth_client.instances.resize_instance(instance_id,
resize_flavor.id)
self.assert_instance_action(instance_id, expected_states,
expected_http_code)
instance = self.get_instance(instance_id)
self.assert_equal(instance.flavor['id'], resize_flavor.id,
def run_wait_for_instance_resize_flavor(
self, expected_states=['RESIZE', 'ACTIVE']):
self.report.log("Waiting for resize to '%s' on instance: %s" %
(self.resize_flavor_id, self.instance_info.id))
self._assert_instance_states(self.instance_info.id, expected_states)
instance = self.get_instance(self.instance_info.id)
self.assert_equal(self.resize_flavor_id, instance.flavor['id'],
'Unexpected resize flavor_id')

9
trove/tests/scenario/runners/instance_create_runners.py
View File

@ -309,11 +309,16 @@ class InstanceCreateRunner(TestRunner):
"Definition of user '%s' specifies databases not included in "
"the list of initial databases." % user['name'])
def run_initialized_instance_delete(self, expected_states=['SHUTDOWN'],
expected_http_code=202):
def run_initialized_instance_delete(self, expected_http_code=202):
if self.init_inst_id:
self.auth_client.instances.delete(self.init_inst_id)
self.assert_client_code(expected_http_code)
else:
raise SkipTest("Cleanup is not required.")
def run_wait_for_initialized_instance_delete(self,
expected_states=['SHUTDOWN']):
if self.init_inst_id:
self.assert_all_gone(self.init_inst_id, expected_states[-1])
else:
raise SkipTest("Cleanup is not required.")