openstack/rally-openstack
Code Issues Proposed changes

Merge "Using 'ready_statuses' instead of 'is_ready'"

Browse Source
This commit is contained in:
Jenkins 2015-12-01 13:23:25 +00:00 committed by Gerrit Code Review
commit 394a7ad24e
16 changed files with 94 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
rally/plugins/openstack/scenarios/ceilometer/utils.py
View File

@ -249,7 +249,7 @@ class CeilometerScenario(scenario.OpenStackScenario):
"""
self.clients("ceilometer").alarms.set_state(alarm.alarm_id, state)
return bench_utils.wait_for(alarm,
is_ready=bench_utils.resource_is(state),
ready_statuses=[state],
update_resource=bench_utils
.get_from_manager(),
timeout=timeout, check_interval=1)

14
rally/plugins/openstack/scenarios/cinder/utils.py
View File

@ -139,7 +139,7 @@ class CinderScenario(scenario.OpenStackScenario):
time.sleep(CONF.benchmark.cinder_volume_create_prepoll_delay)
volume = bench_utils.wait_for(
volume,
is_ready=bench_utils.resource_is("available"),
ready_statuses=["available"],
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval
@ -198,7 +198,7 @@ class CinderScenario(scenario.OpenStackScenario):
volume.extend(volume, new_size)
volume = bench_utils.wait_for(
volume,
is_ready=bench_utils.resource_is("available"),
ready_statuses=["available"],
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval
@ -226,7 +226,7 @@ class CinderScenario(scenario.OpenStackScenario):
# we need to wait until it will be available.
volume = bench_utils.wait_for(
volume,
is_ready=bench_utils.resource_is("available"),
ready_statuses=["available"],
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval
@ -235,7 +235,7 @@ class CinderScenario(scenario.OpenStackScenario):
image = self.clients("glance").images.get(image_id)
image = bench_utils.wait_for(
image,
is_ready=bench_utils.resource_is("active"),
ready_statuses=["active"],
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.glance_image_create_timeout,
check_interval=CONF.benchmark.glance_image_create_poll_interval
@ -264,7 +264,7 @@ class CinderScenario(scenario.OpenStackScenario):
time.sleep(CONF.benchmark.cinder_volume_create_prepoll_delay)
snapshot = bench_utils.wait_for(
snapshot,
is_ready=bench_utils.resource_is("available"),
ready_statuses=["available"],
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval
@ -299,7 +299,7 @@ class CinderScenario(scenario.OpenStackScenario):
backup = self.clients("cinder").backups.create(volume_id, **kwargs)
return bench_utils.wait_for(
backup,
is_ready=bench_utils.resource_is("available"),
ready_statuses=["available"],
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval
@ -334,7 +334,7 @@ class CinderScenario(scenario.OpenStackScenario):
restored_volume = self.clients("cinder").volumes.get(restore.volume_id)
return bench_utils.wait_for(
restored_volume,
is_ready=bench_utils.resource_is("available"),
ready_statuses=["available"],
update_resource=bench_utils.get_from_manager(),
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval

2
rally/plugins/openstack/scenarios/ec2/utils.py
View File

@ -79,7 +79,7 @@ class EC2Scenario(scenario.OpenStackScenario):
time.sleep(CONF.benchmark.ec2_server_boot_prepoll_delay)
servers = [utils.wait_for(
server,
is_ready=utils.resource_is("RUNNING"),
ready_statuses=["RUNNING"],
update_resource=self._update_resource,
timeout=CONF.benchmark.ec2_server_boot_timeout,
check_interval=CONF.benchmark.ec2_server_boot_poll_interval

2
rally/plugins/openstack/scenarios/glance/utils.py
View File

@ -93,7 +93,7 @@ class GlanceScenario(scenario.OpenStackScenario):
image = utils.wait_for(
image,
is_ready=utils.resource_is("active"),
ready_statuses=["active"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.glance_image_create_timeout,
check_interval=CONF.benchmark.

14
rally/plugins/openstack/scenarios/heat/utils.py
View File

@ -147,7 +147,7 @@ class HeatScenario(scenario.OpenStackScenario):
stack = utils.wait_for(
stack,
is_ready=utils.resource_is("CREATE_COMPLETE"),
ready_statuses=["CREATE_COMPLETE"],
update_resource=utils.get_from_manager(["CREATE_FAILED"]),
timeout=CONF.benchmark.heat_stack_create_timeout,
check_interval=CONF.benchmark.heat_stack_create_poll_interval)
@ -181,7 +181,7 @@ class HeatScenario(scenario.OpenStackScenario):
time.sleep(CONF.benchmark.heat_stack_update_prepoll_delay)
stack = utils.wait_for(
stack,
is_ready=utils.resource_is("UPDATE_COMPLETE"),
ready_statuses=["UPDATE_COMPLETE"],
update_resource=utils.get_from_manager(["UPDATE_FAILED"]),
timeout=CONF.benchmark.heat_stack_update_timeout,
check_interval=CONF.benchmark.heat_stack_update_poll_interval)
@ -198,7 +198,7 @@ class HeatScenario(scenario.OpenStackScenario):
self.clients("heat").actions.check(stack.id)
utils.wait_for(
stack,
is_ready=utils.resource_is("CHECK_COMPLETE"),
ready_statuses=["CHECK_COMPLETE"],
update_resource=utils.get_from_manager(["CHECK_FAILED"]),
timeout=CONF.benchmark.heat_stack_check_timeout,
check_interval=CONF.benchmark.heat_stack_check_poll_interval)
@ -230,7 +230,7 @@ class HeatScenario(scenario.OpenStackScenario):
self.clients("heat").actions.suspend(stack.id)
utils.wait_for(
stack,
is_ready=utils.resource_is("SUSPEND_COMPLETE"),
ready_statuses=["SUSPEND_COMPLETE"],
update_resource=utils.get_from_manager(
["SUSPEND_FAILED"]),
timeout=CONF.benchmark.heat_stack_suspend_timeout,
@ -246,7 +246,7 @@ class HeatScenario(scenario.OpenStackScenario):
self.clients("heat").actions.resume(stack.id)
utils.wait_for(
stack,
is_ready=utils.resource_is("RESUME_COMPLETE"),
ready_statuses=["RESUME_COMPLETE"],
update_resource=utils.get_from_manager(
["RESUME_FAILED"]),
timeout=CONF.benchmark.heat_stack_resume_timeout,
@ -263,7 +263,7 @@ class HeatScenario(scenario.OpenStackScenario):
stack.id)
utils.wait_for(
stack,
is_ready=utils.resource_is("SNAPSHOT_COMPLETE"),
ready_statuses=["SNAPSHOT_COMPLETE"],
update_resource=utils.get_from_manager(
["SNAPSHOT_FAILED"]),
timeout=CONF.benchmark.heat_stack_snapshot_timeout,
@ -280,7 +280,7 @@ class HeatScenario(scenario.OpenStackScenario):
self.clients("heat").stacks.restore(stack.id, snapshot_id)
utils.wait_for(
stack,
is_ready=utils.resource_is("RESTORE_COMPLETE"),
ready_statuses=["RESTORE_COMPLETE"],
update_resource=utils.get_from_manager(
["RESTORE_FAILED"]),
timeout=CONF.benchmark.heat_stack_restore_timeout,

2
rally/plugins/openstack/scenarios/manila/utils.py
View File

@ -91,7 +91,7 @@ class ManilaScenario(scenario.OpenStackScenario):
time.sleep(CONF.benchmark.manila_share_create_prepoll_delay)
share = utils.wait_for(
share,
is_ready=utils.resource_is("available"),
ready_statuses=["available"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.manila_share_create_timeout,
check_interval=CONF.benchmark.manila_share_create_poll_interval,

3
rally/plugins/openstack/scenarios/murano/utils.py
View File

@ -117,7 +117,8 @@ class MuranoScenario(scenario.OpenStackScenario):
config = CONF.benchmark
utils.wait_for(
environment, is_ready=utils.resource_is("READY"),
environment,
ready_statuses=["READY"],
update_resource=utils.get_from_manager(["DEPLOY FAILURE"]),
timeout=config.murano_deploy_environment_timeout,
check_interval=config.murano_deploy_environment_check_interval

55
rally/plugins/openstack/scenarios/nova/utils.py
View File

@ -141,7 +141,7 @@ class NovaScenario(scenario.OpenStackScenario):
time.sleep(CONF.benchmark.nova_server_boot_prepoll_delay)
server = utils.wait_for(
server,
is_ready=utils.resource_is("ACTIVE"),
ready_statuses=["ACTIVE"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_boot_timeout,
check_interval=CONF.benchmark.nova_server_boot_poll_interval
@ -152,7 +152,8 @@ class NovaScenario(scenario.OpenStackScenario):
server.reboot(reboot_type=reboottype)
time.sleep(CONF.benchmark.nova_server_reboot_prepoll_delay)
utils.wait_for(
server, is_ready=utils.resource_is("ACTIVE"),
server,
ready_statuses=["ACTIVE"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_reboot_timeout,
check_interval=CONF.benchmark.nova_server_reboot_poll_interval
@ -214,7 +215,7 @@ class NovaScenario(scenario.OpenStackScenario):
time.sleep(CONF.benchmark.nova_server_rebuild_prepoll_delay)
utils.wait_for(
server,
is_ready=utils.resource_is("ACTIVE"),
ready_statuses=["ACTIVE"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_rebuild_timeout,
check_interval=CONF.benchmark.nova_server_rebuild_poll_interval
@ -231,7 +232,8 @@ class NovaScenario(scenario.OpenStackScenario):
"""
server.start()
utils.wait_for(
server, is_ready=utils.resource_is("ACTIVE"),
server,
ready_statuses=["ACTIVE"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_start_timeout,
check_interval=CONF.benchmark.nova_server_start_poll_interval
@ -248,7 +250,8 @@ class NovaScenario(scenario.OpenStackScenario):
"""
server.stop()
utils.wait_for(
server, is_ready=utils.resource_is("SHUTOFF"),
server,
ready_statuses=["SHUTOFF"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_stop_timeout,
check_interval=CONF.benchmark.nova_server_stop_poll_interval
@ -266,7 +269,8 @@ class NovaScenario(scenario.OpenStackScenario):
server.rescue()
time.sleep(CONF.benchmark.nova_server_rescue_prepoll_delay)
utils.wait_for(
server, is_ready=utils.resource_is("RESCUE"),
server,
ready_statuses=["RESCUE"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_rescue_timeout,
check_interval=CONF.benchmark.nova_server_rescue_poll_interval
@ -283,7 +287,8 @@ class NovaScenario(scenario.OpenStackScenario):
server.unrescue()
time.sleep(CONF.benchmark.nova_server_unrescue_prepoll_delay)
utils.wait_for(
server, is_ready=utils.resource_is("ACTIVE"),
server,
ready_statuses=["ACTIVE"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_unrescue_timeout,
check_interval=CONF.benchmark.nova_server_unrescue_poll_interval
@ -301,7 +306,8 @@ class NovaScenario(scenario.OpenStackScenario):
server.suspend()
time.sleep(CONF.benchmark.nova_server_suspend_prepoll_delay)
utils.wait_for(
server, is_ready=utils.resource_is("SUSPENDED"),
server,
ready_statuses=["SUSPENDED"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_suspend_timeout,
check_interval=CONF.benchmark.nova_server_suspend_poll_interval
@ -319,7 +325,8 @@ class NovaScenario(scenario.OpenStackScenario):
server.resume()
time.sleep(CONF.benchmark.nova_server_resume_prepoll_delay)
utils.wait_for(
server, is_ready=utils.resource_is("ACTIVE"),
server,
ready_statuses=["ACTIVE"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_resume_timeout,
check_interval=CONF.benchmark.nova_server_resume_poll_interval
@ -337,7 +344,8 @@ class NovaScenario(scenario.OpenStackScenario):
server.pause()
time.sleep(CONF.benchmark.nova_server_pause_prepoll_delay)
utils.wait_for(
server, is_ready=utils.resource_is("PAUSED"),
server,
ready_statuses=["PAUSED"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_pause_timeout,
check_interval=CONF.benchmark.nova_server_pause_poll_interval
@ -355,7 +363,8 @@ class NovaScenario(scenario.OpenStackScenario):
server.unpause()
time.sleep(CONF.benchmark.nova_server_unpause_prepoll_delay)
utils.wait_for(
server, is_ready=utils.resource_is("ACTIVE"),
server,
ready_statuses=["ACTIVE"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_unpause_timeout,
check_interval=CONF.benchmark.nova_server_unpause_poll_interval
@ -373,7 +382,8 @@ class NovaScenario(scenario.OpenStackScenario):
server.shelve()
time.sleep(CONF.benchmark.nova_server_shelve_prepoll_delay)
utils.wait_for(
server, is_ready=utils.resource_is("SHELVED_OFFLOADED"),
server,
ready_statuses=["SHELVED_OFFLOADED"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_shelve_timeout,
check_interval=CONF.benchmark.nova_server_shelve_poll_interval
@ -390,7 +400,8 @@ class NovaScenario(scenario.OpenStackScenario):
server.unshelve()
time.sleep(CONF.benchmark.nova_server_unshelve_prepoll_delay)
utils.wait_for(
server, is_ready=utils.resource_is("ACTIVE"),
server,
ready_statuses=["ACTIVE"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_unshelve_timeout,
check_interval=CONF.benchmark.nova_server_unshelve_poll_interval
@ -481,7 +492,7 @@ class NovaScenario(scenario.OpenStackScenario):
check_interval = CONF.benchmark.nova_server_image_create_poll_interval
image = utils.wait_for(
image,
is_ready=utils.resource_is("ACTIVE"),
ready_statuses=["ACTIVE"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_image_create_timeout,
check_interval=check_interval
@ -560,7 +571,7 @@ class NovaScenario(scenario.OpenStackScenario):
time.sleep(CONF.benchmark.nova_server_boot_prepoll_delay)
servers = [utils.wait_for(
server,
is_ready=utils.resource_is("ACTIVE"),
ready_statuses=["ACTIVE"],
update_resource=utils.
get_from_manager(),
timeout=CONF.benchmark.nova_server_boot_timeout,
@ -628,7 +639,7 @@ class NovaScenario(scenario.OpenStackScenario):
server.resize(flavor)
utils.wait_for(
server,
is_ready=utils.resource_is("VERIFY_RESIZE"),
ready_statuses=["VERIFY_RESIZE"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_resize_timeout,
check_interval=CONF.benchmark.nova_server_resize_poll_interval
@ -639,7 +650,7 @@ class NovaScenario(scenario.OpenStackScenario):
server.confirm_resize()
utils.wait_for(
server,
is_ready=utils.resource_is(status),
ready_statuses=[status],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_resize_confirm_timeout,
check_interval=(
@ -651,7 +662,7 @@ class NovaScenario(scenario.OpenStackScenario):
server.revert_resize()
utils.wait_for(
server,
is_ready=utils.resource_is(status),
ready_statuses=["status"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_resize_revert_timeout,
check_interval=(
@ -667,7 +678,7 @@ class NovaScenario(scenario.OpenStackScenario):
device)
utils.wait_for(
volume,
is_ready=utils.resource_is("in-use"),
ready_statuses=["in-use"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_resize_revert_timeout,
check_interval=(
@ -682,7 +693,7 @@ class NovaScenario(scenario.OpenStackScenario):
volume_id)
utils.wait_for(
volume,
is_ready=utils.resource_is("available"),
ready_statuses=["available"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_detach_volume_timeout,
check_interval=CONF.benchmark.nova_detach_volume_poll_interval
@ -708,7 +719,7 @@ class NovaScenario(scenario.OpenStackScenario):
disk_over_commit=disk_over_commit)
utils.wait_for(
server,
is_ready=utils.resource_is("ACTIVE"),
ready_statuses=["ACTIVE"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_live_migrate_timeout,
check_interval=(
@ -758,7 +769,7 @@ class NovaScenario(scenario.OpenStackScenario):
server_admin.migrate()
utils.wait_for(
server,
is_ready=utils.resource_is("VERIFY_RESIZE"),
ready_statuses=["VERIFY_RESIZE"],
update_resource=utils.get_from_manager(),
timeout=CONF.benchmark.nova_server_migrate_timeout,
check_interval=(

3
tests/unit/plugins/openstack/scenarios/ceilometer/test_utils.py
View File

@ -147,10 +147,9 @@ class CeilometerScenarioTestCase(test.ScenarioTestCase):
return_alarm = self.scenario._set_alarm_state(alarm, "ok", 100)
self.mock_wait_for.mock.assert_called_once_with(
alarm,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["ok"],
update_resource=self.mock_get_from_manager.mock.return_value,
timeout=100, check_interval=1)
self.mock_resource_is.mock.assert_called_once_with("ok")
self.mock_get_from_manager.mock.assert_called_once_with()
self.assertEqual(self.mock_wait_for.mock.return_value, return_alarm)
self._test_atomic_action_timer(self.scenario.atomic_actions(),

27
tests/unit/plugins/openstack/scenarios/cinder/test_utils.py
View File

@ -98,12 +98,11 @@ class CinderScenarioTestCase(test.ScenarioTestCase):
return_volume = self.scenario._create_volume(1)
self.mock_wait_for.mock.assert_called_once_with(
self.mock_wrap.return_value.create_volume.return_value,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["available"],
update_resource=self.mock_get_from_manager.mock.return_value,
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval
)
self.mock_resource_is.mock.assert_called_once_with("available")
self.mock_get_from_manager.mock.assert_called_once_with()
self.assertEqual(self.mock_wait_for.mock.return_value, return_volume)
self._test_atomic_action_timer(self.scenario.atomic_actions(),
@ -122,12 +121,11 @@ class CinderScenarioTestCase(test.ScenarioTestCase):
self.mock_wait_for.mock.assert_called_once_with(
self.mock_wrap.return_value.create_volume.return_value,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["available"],
update_resource=self.mock_get_from_manager.mock.return_value,
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval
)
self.mock_resource_is.mock.assert_called_once_with("available")
self.mock_get_from_manager.mock.assert_called_once_with()
self.assertEqual(self.mock_wait_for.mock.return_value, return_volume)
self._test_atomic_action_timer(self.scenario.atomic_actions(),
@ -173,12 +171,11 @@ class CinderScenarioTestCase(test.ScenarioTestCase):
volume.extend.assert_called_once_with(volume, 3)
self.mock_wait_for.mock.assert_called_once_with(
volume,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["available"],
update_resource=self.mock_get_from_manager.mock.return_value,
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval
)
self.mock_resource_is.mock.assert_called_once_with("available")
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.extend_volume")
@ -189,12 +186,11 @@ class CinderScenarioTestCase(test.ScenarioTestCase):
self.scenario._extend_volume(volume, 2)
self.mock_wait_for.mock.assert_called_once_with(
volume,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["available"],
update_resource=self.mock_get_from_manager.mock.return_value,
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval
)
self.mock_resource_is.mock.assert_called_once_with("available")
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.extend_volume")
@ -215,14 +211,14 @@ class CinderScenarioTestCase(test.ScenarioTestCase):
self.mock_wait_for.mock.assert_has_calls([
mock.call(
volume,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["available"],
update_resource=self.mock_get_from_manager.mock.return_value,
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.
cinder_volume_create_poll_interval),
mock.call(
self.clients("glance").images.get.return_value,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["active"],
update_resource=self.mock_get_from_manager.mock.return_value,
timeout=CONF.benchmark.glance_image_create_timeout,
check_interval=CONF.benchmark.
@ -230,8 +226,6 @@ class CinderScenarioTestCase(test.ScenarioTestCase):
])
self.mock_get_from_manager.mock.assert_has_calls([mock.call(),
mock.call()])
self.mock_resource_is.mock.assert_has_calls([mock.call("available"),
mock.call("active")])
self.clients("glance").images.get.assert_called_once_with(1)
def test__create_snapshot(self):
@ -239,12 +233,11 @@ class CinderScenarioTestCase(test.ScenarioTestCase):
self.mock_wait_for.mock.assert_called_once_with(
self.mock_wrap.return_value.create_snapshot.return_value,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["available"],
update_resource=self.mock_get_from_manager.mock.return_value,
timeout=cfg.CONF.benchmark.cinder_volume_create_timeout,
check_interval=cfg.CONF.benchmark
.cinder_volume_create_poll_interval)
self.mock_resource_is.mock.assert_called_once_with("available")
self.mock_get_from_manager.mock.assert_called_once_with()
self.assertEqual(self.mock_wait_for.mock.return_value, return_snapshot)
self._test_atomic_action_timer(self.scenario.atomic_actions(),
@ -271,12 +264,11 @@ class CinderScenarioTestCase(test.ScenarioTestCase):
self.mock_wait_for.mock.assert_called_once_with(
self.clients("cinder").backups.create.return_value,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["available"],
update_resource=self.mock_get_from_manager.mock.return_value,
timeout=cfg.CONF.benchmark.cinder_volume_create_timeout,
check_interval=cfg.CONF.benchmark
.cinder_volume_create_poll_interval)
self.mock_resource_is.mock.assert_called_once_with("available")
self.mock_get_from_manager.mock.assert_called_once_with()
self.assertEqual(self.mock_wait_for.mock.return_value, return_backup)
self._test_atomic_action_timer(self.scenario.atomic_actions(),
@ -308,12 +300,11 @@ class CinderScenarioTestCase(test.ScenarioTestCase):
self.mock_wait_for.mock.assert_called_once_with(
restore,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["available"],
update_resource=self.mock_get_from_manager.mock.return_value,
timeout=cfg.CONF.benchmark.cinder_volume_create_timeout,
check_interval=cfg.CONF.benchmark
.cinder_volume_create_poll_interval)
self.mock_resource_is.mock.assert_called_once_with("available")
self.mock_get_from_manager.mock.assert_called_once_with()
self.assertEqual(self.mock_wait_for.mock.return_value, return_restore)
self._test_atomic_action_timer(self.scenario.atomic_actions(),

5
tests/unit/plugins/openstack/scenarios/ec2/test_utils.py
View File

@ -53,20 +53,19 @@ class EC2ScenarioTestCase(test.ScenarioTestCase):
expected = [
mock.call(
self.server1,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["RUNNING"],
update_resource=ec2_scenario._update_resource,
check_interval=CONF.benchmark.ec2_server_boot_poll_interval,
timeout=CONF.benchmark.ec2_server_boot_timeout
),
mock.call(
self.server2,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["RUNNING"],
update_resource=ec2_scenario._update_resource,
check_interval=CONF.benchmark.ec2_server_boot_poll_interval,
timeout=CONF.benchmark.ec2_server_boot_timeout
)
]
self.mock_wait_for.mock.assert_has_calls(expected)
self.mock_resource_is.mock.assert_has_calls([mock.call("RUNNING")])
self._test_atomic_action_timer(ec2_scenario.atomic_actions(),
"ec2.boot_servers")

6
tests/unit/plugins/openstack/scenarios/glance/test_utils.py
View File

@ -50,10 +50,9 @@ class GlanceScenarioTestCase(test.ScenarioTestCase):
self.mock_wait_for.mock.assert_called_once_with(
self.image,
update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["active"],
check_interval=CONF.benchmark.glance_image_create_poll_interval,
timeout=CONF.benchmark.glance_image_create_timeout)
self.mock_resource_is.mock.assert_called_once_with("active")
self.mock_get_from_manager.mock.assert_called_once_with()
self.assertEqual(self.mock_wait_for.mock.return_value, return_image)
self._test_atomic_action_timer(scenario.atomic_actions(),
@ -68,10 +67,9 @@ class GlanceScenarioTestCase(test.ScenarioTestCase):
self.mock_wait_for.mock.assert_called_once_with(
self.image,
update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["active"],
check_interval=CONF.benchmark.glance_image_create_poll_interval,
timeout=CONF.benchmark.glance_image_create_timeout)
self.mock_resource_is.mock.assert_called_once_with("active")
self.mock_get_from_manager.mock.assert_called_once_with()
self.assertEqual(self.mock_wait_for.mock.return_value, return_image)
self._test_atomic_action_timer(scenario.atomic_actions(),

21
tests/unit/plugins/openstack/scenarios/heat/test_utils.py
View File

@ -60,10 +60,9 @@ class HeatScenarioTestCase(test.ScenarioTestCase):
self.mock_wait_for.mock.assert_called_once_with(
self.stack,
update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["CREATE_COMPLETE"],
check_interval=CONF.benchmark.heat_stack_create_poll_interval,
timeout=CONF.benchmark.heat_stack_create_timeout)
self.mock_resource_is.mock.assert_called_once_with("CREATE_COMPLETE")
self.mock_get_from_manager.mock.assert_called_once_with(
["CREATE_FAILED"])
self.assertEqual(self.mock_wait_for.mock.return_value, return_stack)
@ -85,10 +84,9 @@ class HeatScenarioTestCase(test.ScenarioTestCase):
self.mock_wait_for.mock.assert_called_once_with(
self.stack,
update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["UPDATE_COMPLETE"],
check_interval=CONF.benchmark.heat_stack_update_poll_interval,
timeout=CONF.benchmark.heat_stack_update_timeout)
self.mock_resource_is.mock.assert_called_once_with("UPDATE_COMPLETE")
self.mock_get_from_manager.mock.assert_called_once_with(
["UPDATE_FAILED"])
self._test_atomic_action_timer(scenario.atomic_actions(),
@ -102,10 +100,9 @@ class HeatScenarioTestCase(test.ScenarioTestCase):
self.mock_wait_for.mock.assert_called_once_with(
self.stack,
update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["CHECK_COMPLETE"],
check_interval=CONF.benchmark.heat_stack_check_poll_interval,
timeout=CONF.benchmark.heat_stack_check_timeout)
self.mock_resource_is.mock.assert_called_once_with("CHECK_COMPLETE")
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.check_stack")
@ -132,10 +129,9 @@ class HeatScenarioTestCase(test.ScenarioTestCase):
self.mock_wait_for.mock.assert_called_once_with(
self.stack,
update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["SUSPEND_COMPLETE"],
check_interval=CONF.benchmark.heat_stack_suspend_poll_interval,
timeout=CONF.benchmark.heat_stack_suspend_timeout)
self.mock_resource_is.mock.assert_called_once_with("SUSPEND_COMPLETE")
self.mock_get_from_manager.mock.assert_called_once_with(
["SUSPEND_FAILED"])
self._test_atomic_action_timer(scenario.atomic_actions(),
@ -149,10 +145,9 @@ class HeatScenarioTestCase(test.ScenarioTestCase):
self.mock_wait_for.mock.assert_called_once_with(
self.stack,
update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["RESUME_COMPLETE"],
check_interval=CONF.benchmark.heat_stack_resume_poll_interval,
timeout=CONF.benchmark.heat_stack_resume_timeout)
self.mock_resource_is.mock.assert_called_once_with("RESUME_COMPLETE")
self.mock_get_from_manager.mock.assert_called_once_with(
["RESUME_FAILED"])
self._test_atomic_action_timer(scenario.atomic_actions(),
@ -166,10 +161,9 @@ class HeatScenarioTestCase(test.ScenarioTestCase):
self.mock_wait_for.mock.assert_called_once_with(
self.stack,
update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["SNAPSHOT_COMPLETE"],
check_interval=CONF.benchmark.heat_stack_snapshot_poll_interval,
timeout=CONF.benchmark.heat_stack_snapshot_timeout)
self.mock_resource_is.mock.assert_called_once_with("SNAPSHOT_COMPLETE")
self.mock_get_from_manager.mock.assert_called_once_with(
["SNAPSHOT_FAILED"])
self._test_atomic_action_timer(scenario.atomic_actions(),
@ -183,10 +177,9 @@ class HeatScenarioTestCase(test.ScenarioTestCase):
self.mock_wait_for.mock.assert_called_once_with(
self.stack,
update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["RESTORE_COMPLETE"],
check_interval=CONF.benchmark.heat_stack_restore_poll_interval,
timeout=CONF.benchmark.heat_stack_restore_timeout)
self.mock_resource_is.mock.assert_called_once_with("RESTORE_COMPLETE")
self.mock_get_from_manager.mock.assert_called_once_with(
["RESTORE_FAILED"])
self._test_atomic_action_timer(scenario.atomic_actions(),

3
tests/unit/plugins/openstack/scenarios/manila/test_utils.py
View File

@ -53,10 +53,9 @@ class ManilaScenarioTestCase(test.ScenarioTestCase):
self.mock_wait_for.mock.assert_called_once_with(
fake_share,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["available"],
update_resource=self.mock_get_from_manager.mock.return_value,
timeout=300, check_interval=3)
self.mock_resource_is.mock.assert_called_once_with("available")
self.mock_get_from_manager.mock.assert_called_once_with()
@mock.patch(BM_UTILS + "wait_for_status")

3
tests/unit/plugins/openstack/scenarios/murano/test_utils.py
View File

@ -93,12 +93,11 @@ class MuranoScenarioTestCase(test.ScenarioTestCase):
self.mock_wait_for.mock.assert_called_once_with(
environment,
update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["READY"],
check_interval=config.murano_deploy_environment_check_interval,
timeout=config.murano_deploy_environment_timeout)
self.mock_get_from_manager.mock.assert_called_once_with(
["DEPLOY FAILURE"])
self.mock_resource_is.mock.assert_called_once_with("READY")
self._test_atomic_action_timer(scenario.atomic_actions(),
"murano.deploy_environment")

55
tests/unit/plugins/openstack/scenarios/nova/test_utils.py
View File

@ -110,11 +110,10 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
**kwargs)
self.mock_wait_for.mock.assert_called_once_with(
self.server,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["ACTIVE"],
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.nova_server_boot_poll_interval,
timeout=CONF.benchmark.nova_server_boot_timeout)
self.mock_resource_is.mock.assert_called_once_with("ACTIVE")
self.mock_get_from_manager.mock.assert_called_once_with()
self.assertEqual(self.mock_wait_for.mock.return_value, return_server)
@ -153,11 +152,10 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
self.server.suspend.assert_called_once_with()
self.mock_wait_for.mock.assert_called_once_with(
self.server,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["SUSPENDED"],
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.nova_server_suspend_poll_interval,
timeout=CONF.benchmark.nova_server_suspend_timeout)
self.mock_resource_is.mock.assert_called_once_with("SUSPENDED")
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.suspend_server")
@ -168,11 +166,10 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
self.server.resume.assert_called_once_with()
self.mock_wait_for.mock.assert_called_once_with(
self.server,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["ACTIVE"],
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.nova_server_resume_poll_interval,
timeout=CONF.benchmark.nova_server_resume_timeout)
self.mock_resource_is.mock.assert_called_once_with("ACTIVE")
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.resume_server")
@ -183,11 +180,10 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
self.server.pause.assert_called_once_with()
self.mock_wait_for.mock.assert_called_once_with(
self.server,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["PAUSED"],
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.nova_server_pause_poll_interval,
timeout=CONF.benchmark.nova_server_pause_timeout)
self.mock_resource_is.mock.assert_called_once_with("PAUSED")
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.pause_server")
@ -198,11 +194,10 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
self.server.unpause.assert_called_once_with()
self.mock_wait_for.mock.assert_called_once_with(
self.server,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["ACTIVE"],
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.nova_server_unpause_poll_interval,
timeout=CONF.benchmark.nova_server_unpause_timeout)
self.mock_resource_is.mock.assert_called_once_with("ACTIVE")
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.unpause_server")
@ -213,11 +208,10 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
self.server.shelve.assert_called_once_with()
self.mock_wait_for.mock.assert_called_once_with(
self.server,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["SHELVED_OFFLOADED"],
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.nova_server_shelve_poll_interval,
timeout=CONF.benchmark.nova_server_shelve_timeout)
self.mock_resource_is.mock.assert_called_once_with("SHELVED_OFFLOADED")
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.shelve_server")
@ -228,11 +222,10 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
self.server.unshelve.assert_called_once_with()
self.mock_wait_for.mock.assert_called_once_with(
self.server,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["ACTIVE"],
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.nova_server_unshelve_poll_interval,
timeout=CONF.benchmark.nova_server_unshelve_timeout)
self.mock_resource_is.mock.assert_called_once_with("ACTIVE")
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.unshelve_server")
@ -243,12 +236,11 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
return_image = nova_scenario._create_image(self.server)
self.mock_wait_for.mock.assert_called_once_with(
self.image,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["ACTIVE"],
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.
nova_server_image_create_poll_interval,
timeout=CONF.benchmark.nova_server_image_create_timeout)
self.mock_resource_is.mock.assert_called_once_with("ACTIVE")
self.mock_get_from_manager.mock.assert_called_once_with()
self.assertEqual(self.mock_wait_for.mock.return_value, return_image)
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
@ -290,11 +282,10 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
self.server.reboot.assert_called_once_with(reboot_type="HARD")
self.mock_wait_for.mock.assert_called_once_with(
self.server,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["ACTIVE"],
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.nova_server_reboot_poll_interval,
timeout=CONF.benchmark.nova_server_reboot_timeout)
self.mock_resource_is.mock.assert_called_once_with("ACTIVE")
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.reboot_server")
@ -305,11 +296,10 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
self.server.reboot.assert_called_once_with(reboot_type="SOFT")
self.mock_wait_for.mock.assert_called_once_with(
self.server,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["ACTIVE"],
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.nova_server_reboot_poll_interval,
timeout=CONF.benchmark.nova_server_reboot_timeout)
self.mock_resource_is.mock.assert_called_once_with("ACTIVE")
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.soft_reboot_server")
@ -320,11 +310,10 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
self.server.rebuild.assert_called_once_with("img", fakearg="fakearg")
self.mock_wait_for.mock.assert_called_once_with(
self.server,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["ACTIVE"],
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.nova_server_rebuild_poll_interval,
timeout=CONF.benchmark.nova_server_rebuild_timeout)
self.mock_resource_is.mock.assert_called_once_with("ACTIVE")
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.rebuild_server")
@ -335,11 +324,10 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
self.server.start.assert_called_once_with()
self.mock_wait_for.mock.assert_called_once_with(
self.server,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["ACTIVE"],
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.nova_server_start_poll_interval,
timeout=CONF.benchmark.nova_server_start_timeout)
self.mock_resource_is.mock.assert_called_once_with("ACTIVE")
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.start_server")
@ -350,11 +338,10 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
self.server.stop.assert_called_once_with()
self.mock_wait_for.mock.assert_called_once_with(
self.server,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["SHUTOFF"],
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.nova_server_stop_poll_interval,
timeout=CONF.benchmark.nova_server_stop_timeout)
self.mock_resource_is.mock.assert_called_once_with("SHUTOFF")
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.stop_server")
@ -365,11 +352,10 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
self.server.rescue.assert_called_once_with()
self.mock_wait_for.mock.assert_called_once_with(
self.server,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["RESCUE"],
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.nova_server_rescue_poll_interval,
timeout=CONF.benchmark.nova_server_rescue_timeout)
self.mock_resource_is.mock.assert_called_once_with("RESCUE")
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.rescue_server")
@ -380,11 +366,10 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
self.server.unrescue.assert_called_once_with()
self.mock_wait_for.mock.assert_called_once_with(
self.server,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["ACTIVE"],
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.nova_server_unrescue_poll_interval,
timeout=CONF.benchmark.nova_server_unrescue_timeout)
self.mock_resource_is.mock.assert_called_once_with("ACTIVE")
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.unrescue_server")
@ -475,15 +460,13 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
wait_for_calls = [
mock.call(
servers[i],
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["ACTIVE"],
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.nova_server_boot_poll_interval,
timeout=CONF.benchmark.nova_server_boot_timeout)
for i in range(instances_amount)]
self.mock_wait_for.mock.assert_has_calls(wait_for_calls)
self.mock_resource_is.mock.assert_has_calls([
mock.call("ACTIVE") for i in range(instances_amount)])
self.mock_get_from_manager.mock.assert_has_calls(
[mock.call() for i in range(instances_amount)])
self._test_atomic_action_timer(scenario.atomic_actions(),
@ -621,12 +604,11 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
self.mock_wait_for.mock.assert_called_once_with(
self.server,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["ACTIVE"],
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.
nova_server_live_migrate_poll_interval,
timeout=CONF.benchmark.nova_server_live_migrate_timeout)
self.mock_resource_is.mock.assert_called_once_with("ACTIVE")
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.live_migrate")
@ -662,11 +644,10 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
self.mock_wait_for.mock.assert_called_once_with(
fake_server,
is_ready=self.mock_resource_is.mock.return_value,
ready_statuses=["VERIFY_RESIZE"],
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.nova_server_migrate_poll_interval,
timeout=CONF.benchmark.nova_server_migrate_timeout)
self.mock_resource_is.mock.assert_called_once_with("VERIFY_RESIZE")
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.migrate")