Using 'ready_statuses' instead of 'is_ready'

We are replacing wait_for by wait_for_status now. Changes in this patch
could be apply first, because those changes don't need changes in
wait_for_status function now.

Change-Id: I5240b9df9099208bb847255c9e3ce956f9f718d3

rally/plugins/openstack/scenarios/ceilometer/utils.py

@@ -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)

rally/plugins/openstack/scenarios/cinder/utils.py

@@ -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

rally/plugins/openstack/scenarios/ec2/utils.py

@@ -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

rally/plugins/openstack/scenarios/glance/utils.py

@@ -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.

rally/plugins/openstack/scenarios/heat/utils.py

@@ -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,

rally/plugins/openstack/scenarios/manila/utils.py

@@ -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,

rally/plugins/openstack/scenarios/murano/utils.py

@@ -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

rally/plugins/openstack/scenarios/nova/utils.py

@@ -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=(

tests/unit/plugins/openstack/scenarios/ceilometer/test_utils.py

@@ -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(),

tests/unit/plugins/openstack/scenarios/cinder/test_utils.py

@@ -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(),

tests/unit/plugins/openstack/scenarios/ec2/test_utils.py

@@ -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")

tests/unit/plugins/openstack/scenarios/glance/test_utils.py

@@ -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(),

tests/unit/plugins/openstack/scenarios/heat/test_utils.py

@@ -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(),

tests/unit/plugins/openstack/scenarios/manila/test_utils.py

@@ -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")

tests/unit/plugins/openstack/scenarios/murano/test_utils.py

@@ -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")
 

tests/unit/plugins/openstack/scenarios/nova/test_utils.py

@@ -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")