openstack/rally-openstack
Code Issues Proposed changes

Better Scenario test case fixtures

Browse Source 
This adds five persistent fixtures for Scenario test cases; previously
they had been variously mocked, patched, etc., in different ways
individually in many test cases. It improves the way those fixtures
are used, mostly by using the .return_value attribute of Mock objects
instead of calling the Mock objects in the test cases and dealing with
strange side effects of that. It also adds assertions for
get_from_manager() calls.

Change-Id: I81a69683ef8ca0fc00bb408c951ec2f9a98e7ba0
This commit is contained in:
Chris St. Pierre
2015-06-17 09:59:40 -05:00
parent b94ec1d62d
commit 434e8173fa
29 changed files with 473 additions and 449 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
tests/unit/plugins/openstack/scenarios/authenticate/test_authenticate.py
View File

@@ -22,7 +22,7 @@ AUTHENTICATE_MODULE = (
"rally.plugins.openstack.scenarios.authenticate.authenticate") "rally.plugins.openstack.scenarios.authenticate.authenticate")
class AuthenticateTestCase(test.ClientsTestCase): class AuthenticateTestCase(test.ScenarioTestCase):
def test_keystone(self): def test_keystone(self):
scenario = authenticate.Authenticate() scenario = authenticate.Authenticate()

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

@@ -15,27 +15,17 @@
import copy import copy
import mock import mock
from oslotest import mockpatch
from rally.plugins.openstack.scenarios.ceilometer import utils from rally.plugins.openstack.scenarios.ceilometer import utils
from tests.unit import test from tests.unit import test
BM_UTILS = "rally.task.utils"
CEILOMETER_UTILS = "rally.plugins.openstack.scenarios.ceilometer.utils" CEILOMETER_UTILS = "rally.plugins.openstack.scenarios.ceilometer.utils"
class CeilometerScenarioTestCase(test.ClientsTestCase): class CeilometerScenarioTestCase(test.ScenarioTestCase):
def setUp(self): def setUp(self):
super(CeilometerScenarioTestCase, self).setUp() super(CeilometerScenarioTestCase, self).setUp()
self.scenario = utils.CeilometerScenario() self.scenario = utils.CeilometerScenario()
self.res_is = mockpatch.Patch(BM_UTILS + ".resource_is")
self.get_fm = mockpatch.Patch(BM_UTILS + ".get_from_manager")
self.wait_for = mockpatch.Patch(CEILOMETER_UTILS +
".bench_utils.wait_for")
self.useFixture(self.wait_for)
self.useFixture(self.res_is)
self.useFixture(self.get_fm)
self.gfm = self.get_fm.mock
def test__list_alarms_by_id(self): def test__list_alarms_by_id(self):
self.assertEqual(self.clients("ceilometer").alarms.get.return_value, self.assertEqual(self.clients("ceilometer").alarms.get.return_value,
@@ -112,13 +102,14 @@ class CeilometerScenarioTestCase(test.ClientsTestCase):
alarm = mock.Mock() alarm = mock.Mock()
self.clients("ceilometer").alarms.create.return_value = alarm self.clients("ceilometer").alarms.create.return_value = alarm
return_alarm = self.scenario._set_alarm_state(alarm, "ok", 100) return_alarm = self.scenario._set_alarm_state(alarm, "ok", 100)
self.wait_for.mock.assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
alarm, alarm,
is_ready=self.res_is.mock(), is_ready=self.mock_resource_is.mock.return_value,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
timeout=100, check_interval=1) timeout=100, check_interval=1)
self.res_is.mock.assert_has_calls([mock.call("ok")]) self.mock_resource_is.mock.assert_called_once_with("ok")
self.assertEqual(self.wait_for.mock(), return_alarm) 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(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
"ceilometer.set_alarm_state") "ceilometer.set_alarm_state")

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

@@ -15,32 +15,20 @@
import mock import mock
from oslo_config import cfg from oslo_config import cfg
from oslotest import mockpatch
from rally import exceptions from rally import exceptions
from rally.plugins.openstack.scenarios.cinder import utils from rally.plugins.openstack.scenarios.cinder import utils
from tests.unit import fakes from tests.unit import fakes
from tests.unit import test from tests.unit import test
BM_UTILS = "rally.task.utils"
CINDER_UTILS = "rally.plugins.openstack.scenarios.cinder.utils" CINDER_UTILS = "rally.plugins.openstack.scenarios.cinder.utils"
CONF = cfg.CONF
class CinderScenarioTestCase(test.ClientsTestCase): class CinderScenarioTestCase(test.ScenarioTestCase):
def setUp(self): def setUp(self):
super(CinderScenarioTestCase, self).setUp() super(CinderScenarioTestCase, self).setUp()
self.res_is = mockpatch.Patch(BM_UTILS + ".resource_is")
self.get_fm = mockpatch.Patch(BM_UTILS + ".get_from_manager")
self.wait_for = mockpatch.Patch(CINDER_UTILS + ".bench_utils.wait_for")
self.wait_for_delete = mockpatch.Patch(
CINDER_UTILS + ".bench_utils.wait_for_delete")
self.useFixture(self.wait_for)
self.useFixture(self.wait_for_delete)
self.useFixture(self.res_is)
self.useFixture(self.get_fm)
self.gfm = self.get_fm.mock
self.useFixture(mockpatch.Patch("time.sleep"))
self.scenario = utils.CinderScenario() self.scenario = utils.CinderScenario()
def test__list_volumes(self): def test__list_volumes(self):
@@ -101,23 +89,22 @@ class CinderScenarioTestCase(test.ClientsTestCase):
volume, keys, deletes=2, delete_size=3) volume, keys, deletes=2, delete_size=3)
def test__create_volume(self): def test__create_volume(self):
CONF = cfg.CONF
return_volume = self.scenario._create_volume(1) return_volume = self.scenario._create_volume(1)
self.wait_for.mock.assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.clients("cinder").volumes.create.return_value, self.clients("cinder").volumes.create.return_value,
is_ready=self.res_is.mock(), is_ready=self.mock_resource_is.mock.return_value,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
timeout=CONF.benchmark.cinder_volume_create_timeout, timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval check_interval=CONF.benchmark.cinder_volume_create_poll_interval
) )
self.res_is.mock.assert_has_calls([mock.call("available")]) self.mock_resource_is.mock.assert_called_once_with("available")
self.assertEqual(self.wait_for.mock(), return_volume) 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(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.create_volume") "cinder.create_volume")
@mock.patch("rally.plugins.openstack.scenarios.cinder.utils.random") @mock.patch("rally.plugins.openstack.scenarios.cinder.utils.random")
def test__create_volume_with_size_range(self, mock_random): def test__create_volume_with_size_range(self, mock_random):
CONF = cfg.CONF
mock_random.randint.return_value = 3 mock_random.randint.return_value = 3
return_volume = self.scenario._create_volume( return_volume = self.scenario._create_volume(
@@ -127,15 +114,16 @@ class CinderScenarioTestCase(test.ClientsTestCase):
self.clients("cinder").volumes.create.assert_called_once_with( self.clients("cinder").volumes.create.assert_called_once_with(
3, display_name="TestVolume") 3, display_name="TestVolume")
self.wait_for.mock.assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.clients("cinder").volumes.create.return_value, self.clients("cinder").volumes.create.return_value,
is_ready=self.res_is.mock(), is_ready=self.mock_resource_is.mock.return_value,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
timeout=CONF.benchmark.cinder_volume_create_timeout, timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval check_interval=CONF.benchmark.cinder_volume_create_poll_interval
) )
self.res_is.mock.assert_has_calls([mock.call("available")]) self.mock_resource_is.mock.assert_called_once_with("available")
self.assertEqual(self.wait_for.mock(), return_volume) 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(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.create_volume") "cinder.create_volume")
@@ -143,18 +131,18 @@ class CinderScenarioTestCase(test.ClientsTestCase):
cinder = mock.Mock() cinder = mock.Mock()
self.scenario._delete_volume(cinder) self.scenario._delete_volume(cinder)
cinder.delete.assert_called_once_with() cinder.delete.assert_called_once_with()
self.wait_for_delete.mock.assert_called_once_with( self.mock_wait_for_delete.mock.assert_called_once_with(
cinder, cinder,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
timeout=cfg.CONF.benchmark.cinder_volume_create_timeout, timeout=cfg.CONF.benchmark.cinder_volume_create_timeout,
check_interval=cfg.CONF.benchmark check_interval=cfg.CONF.benchmark
.cinder_volume_create_poll_interval) .cinder_volume_create_poll_interval)
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(self.scenario.atomic_actions(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.delete_volume") "cinder.delete_volume")
@mock.patch("rally.plugins.openstack.scenarios.cinder.utils.random") @mock.patch("rally.plugins.openstack.scenarios.cinder.utils.random")
def test__extend_volume_with_size_range(self, mock_random): def test__extend_volume_with_size_range(self, mock_random):
CONF = cfg.CONF
volume = mock.Mock() volume = mock.Mock()
mock_random.randint.return_value = 3 mock_random.randint.return_value = 3
self.clients("cinder").volumes.extend.return_value = volume self.clients("cinder").volumes.extend.return_value = volume
@@ -162,30 +150,31 @@ class CinderScenarioTestCase(test.ClientsTestCase):
self.scenario._extend_volume(volume, new_size={"min": 1, "max": 5}) self.scenario._extend_volume(volume, new_size={"min": 1, "max": 5})
volume.extend.assert_called_once_with(volume, 3) volume.extend.assert_called_once_with(volume, 3)
self.wait_for.mock.assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
volume, volume,
is_ready=self.res_is.mock(), is_ready=self.mock_resource_is.mock.return_value,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
timeout=CONF.benchmark.cinder_volume_create_timeout, timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval check_interval=CONF.benchmark.cinder_volume_create_poll_interval
) )
self.res_is.mock.assert_has_calls([mock.call("available")]) 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(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.extend_volume") "cinder.extend_volume")
def test__extend_volume(self): def test__extend_volume(self):
CONF = cfg.CONF
volume = mock.Mock() volume = mock.Mock()
self.clients("cinder").volumes.extend.return_value = volume self.clients("cinder").volumes.extend.return_value = volume
self.scenario._extend_volume(volume, 2) self.scenario._extend_volume(volume, 2)
self.wait_for.mock.assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
volume, volume,
is_ready=self.res_is.mock(), is_ready=self.mock_resource_is.mock.return_value,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
timeout=CONF.benchmark.cinder_volume_create_timeout, timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval check_interval=CONF.benchmark.cinder_volume_create_poll_interval
) )
self.res_is.mock.assert_has_calls([mock.call("available")]) 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(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.extend_volume") "cinder.extend_volume")
@@ -202,21 +191,41 @@ class CinderScenarioTestCase(test.ClientsTestCase):
volume.upload_to_image.assert_called_once_with(False, "test_vol", volume.upload_to_image.assert_called_once_with(False, "test_vol",
"container", "disk") "container", "disk")
self.assertTrue(self.wait_for.mock.called) self.mock_wait_for.mock.assert_has_calls([
self.assertEqual(2, self.wait_for.mock.call_count) mock.call(
volume,
is_ready=self.mock_resource_is.mock.return_value,
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,
update_resource=self.mock_get_from_manager.mock.return_value,
timeout=CONF.benchmark.glance_image_create_timeout,
check_interval=CONF.benchmark.
glance_image_create_poll_interval)
])
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): def test__create_snapshot(self):
return_snapshot = self.scenario._create_snapshot("uuid", False) return_snapshot = self.scenario._create_snapshot("uuid", False)
self.wait_for.mock.assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.clients("cinder").volume_snapshots.create.return_value, self.clients("cinder").volume_snapshots.create.return_value,
is_ready=self.res_is.mock(), is_ready=self.mock_resource_is.mock.return_value,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
timeout=cfg.CONF.benchmark.cinder_volume_create_timeout, timeout=cfg.CONF.benchmark.cinder_volume_create_timeout,
check_interval=cfg.CONF.benchmark check_interval=cfg.CONF.benchmark
.cinder_volume_create_poll_interval) .cinder_volume_create_poll_interval)
self.res_is.mock.assert_has_calls([mock.call("available")]) self.mock_resource_is.mock.assert_called_once_with("available")
self.assertEqual(self.wait_for.mock(), return_snapshot) 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(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.create_snapshot") "cinder.create_snapshot")
@@ -224,27 +233,29 @@ class CinderScenarioTestCase(test.ClientsTestCase):
snapshot = mock.Mock() snapshot = mock.Mock()
self.scenario._delete_snapshot(snapshot) self.scenario._delete_snapshot(snapshot)
snapshot.delete.assert_called_once_with() snapshot.delete.assert_called_once_with()
self.wait_for_delete.mock.assert_called_once_with( self.mock_wait_for_delete.mock.assert_called_once_with(
snapshot, snapshot,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
timeout=cfg.CONF.benchmark.cinder_volume_create_timeout, timeout=cfg.CONF.benchmark.cinder_volume_create_timeout,
check_interval=cfg.CONF.benchmark check_interval=cfg.CONF.benchmark
.cinder_volume_create_poll_interval) .cinder_volume_create_poll_interval)
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(self.scenario.atomic_actions(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.delete_snapshot") "cinder.delete_snapshot")
def test__create_backup(self): def test__create_backup(self):
return_backup = self.scenario._create_backup("uuid") return_backup = self.scenario._create_backup("uuid")
self.wait_for.mock.assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.clients("cinder").backups.create.return_value, self.clients("cinder").backups.create.return_value,
is_ready=self.res_is.mock(), is_ready=self.mock_resource_is.mock.return_value,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
timeout=cfg.CONF.benchmark.cinder_volume_create_timeout, timeout=cfg.CONF.benchmark.cinder_volume_create_timeout,
check_interval=cfg.CONF.benchmark check_interval=cfg.CONF.benchmark
.cinder_volume_create_poll_interval) .cinder_volume_create_poll_interval)
self.res_is.mock.assert_has_calls([mock.call("available")]) self.mock_resource_is.mock.assert_called_once_with("available")
self.assertEqual(self.wait_for.mock(), return_backup) 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(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.create_backup") "cinder.create_backup")
@@ -252,12 +263,13 @@ class CinderScenarioTestCase(test.ClientsTestCase):
backup = mock.Mock() backup = mock.Mock()
self.scenario._delete_backup(backup) self.scenario._delete_backup(backup)
backup.delete.assert_called_once_with() backup.delete.assert_called_once_with()
self.wait_for_delete.mock.assert_called_once_with( self.mock_wait_for_delete.mock.assert_called_once_with(
backup, backup,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
timeout=cfg.CONF.benchmark.cinder_volume_create_timeout, timeout=cfg.CONF.benchmark.cinder_volume_create_timeout,
check_interval=cfg.CONF.benchmark check_interval=cfg.CONF.benchmark
.cinder_volume_create_poll_interval) .cinder_volume_create_poll_interval)
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(self.scenario.atomic_actions(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.delete_backup") "cinder.delete_backup")
@@ -269,15 +281,16 @@ class CinderScenarioTestCase(test.ClientsTestCase):
return_restore = self.scenario._restore_backup(backup.id, None) return_restore = self.scenario._restore_backup(backup.id, None)
self.wait_for.mock.assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
restore, restore,
is_ready=self.res_is.mock(), is_ready=self.mock_resource_is.mock.return_value,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
timeout=cfg.CONF.benchmark.cinder_volume_create_timeout, timeout=cfg.CONF.benchmark.cinder_volume_create_timeout,
check_interval=cfg.CONF.benchmark check_interval=cfg.CONF.benchmark
.cinder_volume_create_poll_interval) .cinder_volume_create_poll_interval)
self.res_is.mock.assert_has_calls([mock.call("available")]) self.mock_resource_is.mock.assert_called_once_with("available")
self.assertEqual(self.wait_for.mock(), return_restore) 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(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.restore_backup") "cinder.restore_backup")

2
tests/unit/plugins/openstack/scenarios/cinder/test_volumes.py
View File

@@ -26,7 +26,7 @@ class fake_type(object):
name = "fake" name = "fake"
class CinderServersTestCase(test.ClientsTestCase): class CinderServersTestCase(test.ScenarioTestCase):
def test_create_and_list_volume(self): def test_create_and_list_volume(self):
scenario = volumes.CinderVolumes() scenario = volumes.CinderVolumes()

2
tests/unit/plugins/openstack/scenarios/designate/test_utils.py
View File

@@ -22,7 +22,7 @@ from tests.unit import test
DESIGNATE_UTILS = "rally.plugins.openstack.scenarios.designate.utils." DESIGNATE_UTILS = "rally.plugins.openstack.scenarios.designate.utils."
class DesignateScenarioTestCase(test.ClientsTestCase): class DesignateScenarioTestCase(test.ScenarioTestCase):
def setUp(self): def setUp(self):
super(DesignateScenarioTestCase, self).setUp() super(DesignateScenarioTestCase, self).setUp()

21
tests/unit/plugins/openstack/scenarios/ec2/test_servers.py
View File

@@ -21,15 +21,11 @@ from tests.unit import test
UTILS = "rally.plugins.openstack.scenarios.ec2.utils." UTILS = "rally.plugins.openstack.scenarios.ec2.utils."
class EC2ServersTestCase(test.ClientsTestCase): class EC2ServersTestCase(test.ScenarioTestCase):
@mock.patch("rally.task.utils.wait_for",
return_value="running_server")
@mock.patch(UTILS + "ec2_resource_is", return_value="foo_state") @mock.patch(UTILS + "ec2_resource_is", return_value="foo_state")
@mock.patch(UTILS + "time")
@mock.patch(UTILS + "CONF") @mock.patch(UTILS + "CONF")
def test_boot_server(self, mock_conf, mock_time, mock_ec2_resource_is, def test_boot_server(self, mock_conf, mock_ec2_resource_is):
mock_wait_for):
mock_conf.benchmark.ec2_server_boot_prepoll_delay = "foo_delay" mock_conf.benchmark.ec2_server_boot_prepoll_delay = "foo_delay"
mock_conf.benchmark.ec2_server_boot_timeout = "foo_timeout" mock_conf.benchmark.ec2_server_boot_timeout = "foo_timeout"
mock_conf.benchmark.ec2_server_boot_poll_interval = "foo_interval" mock_conf.benchmark.ec2_server_boot_poll_interval = "foo_interval"
@@ -40,9 +36,10 @@ class EC2ServersTestCase(test.ClientsTestCase):
self.clients("ec2").run_instances.return_value = mock_instances self.clients("ec2").run_instances.return_value = mock_instances
server = scenario._boot_server("foo_image", "foo_flavor", foo="bar") server = scenario._boot_server("foo_image", "foo_flavor", foo="bar")
mock_wait_for.assert_called_once_with("foo_inst", is_ready="foo_state", self.mock_wait_for.mock.assert_called_once_with(
update_resource="foo_update", "foo_inst", is_ready="foo_state",
timeout="foo_timeout", update_resource="foo_update",
check_interval="foo_interval") timeout="foo_timeout",
mock_time.sleep.assert_called_once_with("foo_delay") check_interval="foo_interval")
self.assertEqual(server, "running_server") self.mock_sleep.mock.assert_called_once_with("foo_delay")
self.assertEqual(server, self.mock_wait_for.mock.return_value)

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

@@ -38,37 +38,29 @@ class EC2UtilsTestCase(test.TestCase):
resource.update.assert_called_once_with() resource.update.assert_called_once_with()
class EC2ScenarioTestCase(test.ClientsTestCase): class EC2ScenarioTestCase(test.ScenarioTestCase):
def setUp(self): def setUp(self):
super(EC2ScenarioTestCase, self).setUp() super(EC2ScenarioTestCase, self).setUp()
self.server = mock.MagicMock() self.server = mock.MagicMock()
self.reservation = mock.MagicMock(instances=[self.server]) self.reservation = mock.MagicMock(instances=[self.server])
self.res_is = mockpatch.Patch(EC2_UTILS + ".ec2_resource_is") self.mock_resource_is = mockpatch.Patch(EC2_UTILS + ".ec2_resource_is")
self.update_res = mockpatch.Patch( self.mock_update_resource = mockpatch.Patch(
EC2_UTILS + ".EC2Scenario._update_resource") EC2_UTILS + ".EC2Scenario._update_resource")
self.wait_for = mockpatch.Patch(EC2_UTILS + ".utils.wait_for") self.useFixture(self.mock_resource_is)
self.useFixture(self.wait_for) self.useFixture(self.mock_update_resource)
self.useFixture(self.res_is)
self.useFixture(self.update_res)
self.useFixture(mockpatch.Patch("time.sleep"))
def _test_atomic_action_timer(self, atomic_actions, name):
action_duration = atomic_actions.get(name)
self.assertIsNotNone(action_duration)
self.assertIsInstance(action_duration, float)
def test__boot_server(self): def test__boot_server(self):
self.clients("ec2").run_instances.return_value = self.reservation self.clients("ec2").run_instances.return_value = self.reservation
ec2_scenario = utils.EC2Scenario(context={}) ec2_scenario = utils.EC2Scenario(context={})
return_server = ec2_scenario._boot_server("image", "flavor") return_server = ec2_scenario._boot_server("image", "flavor")
expected = mock.call( self.mock_wait_for.mock.assert_called_once_with(
self.server, is_ready=self.res_is.mock(), self.server,
update_resource=self.update_res.mock, is_ready=self.mock_resource_is.mock.return_value,
update_resource=self.mock_update_resource.mock,
check_interval=CONF.benchmark.ec2_server_boot_poll_interval, check_interval=CONF.benchmark.ec2_server_boot_poll_interval,
timeout=CONF.benchmark.ec2_server_boot_timeout) timeout=CONF.benchmark.ec2_server_boot_timeout)
self.assertEqual([expected], self.wait_for.mock.mock_calls) self.mock_resource_is.mock.assert_called_once_with("RUNNING")
self.res_is.mock.assert_has_calls([mock.call("RUNNING")]) self.assertEqual(self.mock_wait_for.mock.return_value, return_server)
self.assertEqual(self.wait_for.mock(), return_server)
self._test_atomic_action_timer(ec2_scenario.atomic_actions(), self._test_atomic_action_timer(ec2_scenario.atomic_actions(),
"ec2.boot_server") "ec2.boot_server")

17
tests/unit/plugins/openstack/scenarios/glance/test_images.py
View File

@@ -71,12 +71,11 @@ class GlanceImagesTestCase(test.TestCase):
mock__create_image.return_value = fake_image mock__create_image.return_value = fake_image
mock__boot_servers.return_value = fake_servers mock__boot_servers.return_value = fake_servers
kwargs = {"fakearg": "f"} kwargs = {"fakearg": "f"}
with mock.patch("rally.plugins.openstack.scenarios."
"glance.utils.time.sleep"): glance_scenario.create_image_and_boot_instances("cf", "url",
glance_scenario.create_image_and_boot_instances("cf", "url", "df", "fid",
"df", "fid", 5, **kwargs)
5, **kwargs) mock__create_image.assert_called_once_with(
mock__create_image.assert_called_once_with( "cf", "url", "df")
"cf", "url", "df") mock__boot_servers.assert_called_once_with(
mock__boot_servers.assert_called_once_with( "image-id-0", "fid", 5, **kwargs)
"image-id-0", "fid", 5, **kwargs)

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

@@ -15,33 +15,21 @@
import tempfile import tempfile
import mock import mock
from oslotest import mockpatch from oslo_config import cfg
from rally.plugins.openstack.scenarios.glance import utils from rally.plugins.openstack.scenarios.glance import utils
from tests.unit import test from tests.unit import test
BM_UTILS = "rally.task.utils"
GLANCE_UTILS = "rally.plugins.openstack.scenarios.glance.utils" GLANCE_UTILS = "rally.plugins.openstack.scenarios.glance.utils"
CONF = cfg.CONF
class GlanceScenarioTestCase(test.ClientsTestCase): class GlanceScenarioTestCase(test.ScenarioTestCase):
def setUp(self): def setUp(self):
super(GlanceScenarioTestCase, self).setUp() super(GlanceScenarioTestCase, self).setUp()
self.image = mock.Mock() self.image = mock.Mock()
self.image1 = mock.Mock() self.image1 = mock.Mock()
self.res_is = mockpatch.Patch(BM_UTILS + ".resource_is")
self.get_fm = mockpatch.Patch(BM_UTILS + ".get_from_manager")
self.wait_for = mockpatch.Patch(GLANCE_UTILS + ".utils.wait_for")
self.wait_for_delete = mockpatch.Patch(
GLANCE_UTILS + ".utils.wait_for_delete")
self.useFixture(self.wait_for)
self.useFixture(self.wait_for_delete)
self.useFixture(self.res_is)
self.useFixture(self.get_fm)
self.gfm = self.get_fm.mock
self.useFixture(mockpatch.Patch("time.sleep"))
self.scenario = utils.GlanceScenario()
def test_list_images(self): def test_list_images(self):
scenario = utils.GlanceScenario() scenario = utils.GlanceScenario()
@@ -59,13 +47,15 @@ class GlanceScenarioTestCase(test.ClientsTestCase):
return_image = scenario._create_image("container_format", return_image = scenario._create_image("container_format",
image_location.name, image_location.name,
"disk_format") "disk_format")
self.wait_for.mock.assert_called_once_with(self.image, self.mock_wait_for.mock.assert_called_once_with(
update_resource=self.gfm(), self.image,
is_ready=self.res_is.mock(), update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=1, is_ready=self.mock_resource_is.mock.return_value,
timeout=120) check_interval=CONF.benchmark.glance_image_create_poll_interval,
self.res_is.mock.assert_has_calls([mock.call("active")]) timeout=CONF.benchmark.glance_image_create_timeout)
self.assertEqual(self.wait_for.mock(), return_image) 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(), self._test_atomic_action_timer(scenario.atomic_actions(),
"glance.create_image") "glance.create_image")
@@ -75,13 +65,15 @@ class GlanceScenarioTestCase(test.ClientsTestCase):
return_image = scenario._create_image("container_format", return_image = scenario._create_image("container_format",
"image_location", "image_location",
"disk_format") "disk_format")
self.wait_for.mock.assert_called_once_with(self.image, self.mock_wait_for.mock.assert_called_once_with(
update_resource=self.gfm(), self.image,
is_ready=self.res_is.mock(), update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=1, is_ready=self.mock_resource_is.mock.return_value,
timeout=120) check_interval=CONF.benchmark.glance_image_create_poll_interval,
self.res_is.mock.assert_has_calls([mock.call("active")]) timeout=CONF.benchmark.glance_image_create_timeout)
self.assertEqual(self.wait_for.mock(), return_image) 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(), self._test_atomic_action_timer(scenario.atomic_actions(),
"glance.create_image") "glance.create_image")
@@ -89,10 +81,11 @@ class GlanceScenarioTestCase(test.ClientsTestCase):
scenario = utils.GlanceScenario() scenario = utils.GlanceScenario()
scenario._delete_image(self.image) scenario._delete_image(self.image)
self.image.delete.assert_called_once_with() self.image.delete.assert_called_once_with()
self.wait_for_delete.mock.assert_called_once_with( self.mock_wait_for_delete.mock.assert_called_once_with(
self.image, self.image,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=1, check_interval=CONF.benchmark.glance_image_delete_poll_interval,
timeout=120) timeout=CONF.benchmark.glance_image_delete_timeout)
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(scenario.atomic_actions(), self._test_atomic_action_timer(scenario.atomic_actions(),
"glance.delete_image") "glance.delete_image")

2
tests/unit/plugins/openstack/scenarios/heat/test_stacks.py
View File

@@ -21,7 +21,7 @@ from tests.unit import test
HEAT_STACKS = "rally.plugins.openstack.scenarios.heat.stacks.HeatStacks" HEAT_STACKS = "rally.plugins.openstack.scenarios.heat.stacks.HeatStacks"
class HeatStacksTestCase(test.ClientsTestCase): class HeatStacksTestCase(test.ScenarioTestCase):
def setUp(self): def setUp(self):
super(HeatStacksTestCase, self).setUp() super(HeatStacksTestCase, self).setUp()

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

@@ -14,33 +14,20 @@
# under the License. # under the License.
import mock import mock
from oslotest import mockpatch
from rally import exceptions from rally import exceptions
from rally.plugins.openstack.scenarios.heat import utils from rally.plugins.openstack.scenarios.heat import utils
from tests.unit import test from tests.unit import test
BM_UTILS = "rally.task.utils"
HEAT_UTILS = "rally.plugins.openstack.scenarios.heat.utils" HEAT_UTILS = "rally.plugins.openstack.scenarios.heat.utils"
CONF = utils.CONF CONF = utils.CONF
class HeatScenarioTestCase(test.ClientsTestCase): class HeatScenarioTestCase(test.ScenarioTestCase):
def setUp(self): def setUp(self):
super(HeatScenarioTestCase, self).setUp() super(HeatScenarioTestCase, self).setUp()
self.stack = mock.Mock() self.stack = mock.Mock()
self.res_is = mockpatch.Patch(BM_UTILS + ".resource_is")
self.get_fm = mockpatch.Patch(BM_UTILS + ".get_from_manager")
self.wait_for = mockpatch.Patch(HEAT_UTILS + ".utils.wait_for")
self.wait_for_delete = mockpatch.Patch(
HEAT_UTILS + ".utils.wait_for_delete")
self.useFixture(self.wait_for)
self.useFixture(self.wait_for_delete)
self.useFixture(self.res_is)
self.useFixture(self.get_fm)
self.gfm = self.get_fm.mock
self.useFixture(mockpatch.Patch("time.sleep"))
self.scenario = utils.HeatScenario() self.scenario = utils.HeatScenario()
self.default_template = "heat_template_version: 2013-05-23" self.default_template = "heat_template_version: 2013-05-23"
self.dummy_parameters = {"dummy_param": "dummy_key"} self.dummy_parameters = {"dummy_param": "dummy_key"}
@@ -71,14 +58,16 @@ class HeatScenarioTestCase(test.ClientsTestCase):
self.assertIn(self.default_template, kwargs.values()) self.assertIn(self.default_template, kwargs.values())
self.assertIn(self.dummy_files, kwargs.values()) self.assertIn(self.dummy_files, kwargs.values())
self.assertIn(self.dummy_environment, kwargs.values()) self.assertIn(self.dummy_environment, kwargs.values())
self.wait_for.mock.assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.stack, self.stack,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.res_is.mock(), is_ready=self.mock_resource_is.mock.return_value,
check_interval=CONF.benchmark.heat_stack_create_poll_interval, check_interval=CONF.benchmark.heat_stack_create_poll_interval,
timeout=CONF.benchmark.heat_stack_create_timeout) timeout=CONF.benchmark.heat_stack_create_timeout)
self.res_is.mock.assert_has_calls([mock.call("CREATE_COMPLETE")]) self.mock_resource_is.mock.assert_called_once_with("CREATE_COMPLETE")
self.assertEqual(self.wait_for.mock(), return_stack) self.mock_get_from_manager.mock.assert_called_once_with(
["CREATE_FAILED"])
self.assertEqual(self.mock_wait_for.mock.return_value, return_stack)
self._test_atomic_action_timer(scenario.atomic_actions(), self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.create_stack") "heat.create_stack")
@@ -94,13 +83,15 @@ class HeatScenarioTestCase(test.ClientsTestCase):
self.assertIn(self.dummy_files, kwargs.values()) self.assertIn(self.dummy_files, kwargs.values())
self.assertIn(self.dummy_environment, kwargs.values()) self.assertIn(self.dummy_environment, kwargs.values())
self.assertIn(self.stack.id, args) self.assertIn(self.stack.id, args)
self.wait_for.mock.assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.stack, self.stack,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.res_is.mock(), is_ready=self.mock_resource_is.mock.return_value,
check_interval=CONF.benchmark.heat_stack_update_poll_interval, check_interval=CONF.benchmark.heat_stack_update_poll_interval,
timeout=CONF.benchmark.heat_stack_update_timeout) timeout=CONF.benchmark.heat_stack_update_timeout)
self.res_is.mock.assert_has_calls([mock.call("UPDATE_COMPLETE")]) 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(), self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.update_stack") "heat.update_stack")
@@ -109,13 +100,13 @@ class HeatScenarioTestCase(test.ClientsTestCase):
scenario._check_stack(self.stack) scenario._check_stack(self.stack)
self.clients("heat").actions.check.assert_called_once_with( self.clients("heat").actions.check.assert_called_once_with(
self.stack.id) self.stack.id)
self.wait_for.mock.assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.stack, self.stack,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.res_is.mock(), is_ready=self.mock_resource_is.mock.return_value,
check_interval=CONF.benchmark.heat_stack_check_poll_interval, check_interval=CONF.benchmark.heat_stack_check_poll_interval,
timeout=CONF.benchmark.heat_stack_check_timeout) timeout=CONF.benchmark.heat_stack_check_timeout)
self.res_is.mock.assert_has_calls([mock.call("CHECK_COMPLETE")]) self.mock_resource_is.mock.assert_called_once_with("CHECK_COMPLETE")
self._test_atomic_action_timer(scenario.atomic_actions(), self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.check_stack") "heat.check_stack")
@@ -123,11 +114,12 @@ class HeatScenarioTestCase(test.ClientsTestCase):
scenario = utils.HeatScenario() scenario = utils.HeatScenario()
scenario._delete_stack(self.stack) scenario._delete_stack(self.stack)
self.stack.delete.assert_called_once_with() self.stack.delete.assert_called_once_with()
self.wait_for_delete.mock.assert_called_once_with( self.mock_wait_for_delete.mock.assert_called_once_with(
self.stack, self.stack,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.heat_stack_delete_poll_interval, check_interval=CONF.benchmark.heat_stack_delete_poll_interval,
timeout=CONF.benchmark.heat_stack_delete_timeout) timeout=CONF.benchmark.heat_stack_delete_timeout)
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(scenario.atomic_actions(), self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.delete_stack") "heat.delete_stack")
@@ -136,13 +128,15 @@ class HeatScenarioTestCase(test.ClientsTestCase):
scenario._suspend_stack(self.stack) scenario._suspend_stack(self.stack)
self.clients("heat").actions.suspend.assert_called_once_with( self.clients("heat").actions.suspend.assert_called_once_with(
self.stack.id) self.stack.id)
self.wait_for.mock.assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.stack, self.stack,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.res_is.mock(), is_ready=self.mock_resource_is.mock.return_value,
check_interval=CONF.benchmark.heat_stack_suspend_poll_interval, check_interval=CONF.benchmark.heat_stack_suspend_poll_interval,
timeout=CONF.benchmark.heat_stack_suspend_timeout) timeout=CONF.benchmark.heat_stack_suspend_timeout)
self.res_is.mock.assert_has_calls([mock.call("SUSPEND_COMPLETE")]) 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(), self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.suspend_stack") "heat.suspend_stack")
@@ -151,13 +145,15 @@ class HeatScenarioTestCase(test.ClientsTestCase):
scenario._resume_stack(self.stack) scenario._resume_stack(self.stack)
self.clients("heat").actions.resume.assert_called_once_with( self.clients("heat").actions.resume.assert_called_once_with(
self.stack.id) self.stack.id)
self.wait_for.mock.assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.stack, self.stack,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.res_is.mock(), is_ready=self.mock_resource_is.mock.return_value,
check_interval=CONF.benchmark.heat_stack_resume_poll_interval, check_interval=CONF.benchmark.heat_stack_resume_poll_interval,
timeout=CONF.benchmark.heat_stack_resume_timeout) timeout=CONF.benchmark.heat_stack_resume_timeout)
self.res_is.mock.assert_has_calls([mock.call("RESUME_COMPLETE")]) 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(), self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.resume_stack") "heat.resume_stack")
@@ -166,13 +162,15 @@ class HeatScenarioTestCase(test.ClientsTestCase):
scenario._snapshot_stack(self.stack) scenario._snapshot_stack(self.stack)
self.clients("heat").stacks.snapshot.assert_called_once_with( self.clients("heat").stacks.snapshot.assert_called_once_with(
self.stack.id) self.stack.id)
self.wait_for.mock.assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.stack, self.stack,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.res_is.mock(), is_ready=self.mock_resource_is.mock.return_value,
check_interval=CONF.benchmark.heat_stack_snapshot_poll_interval, check_interval=CONF.benchmark.heat_stack_snapshot_poll_interval,
timeout=CONF.benchmark.heat_stack_snapshot_timeout) timeout=CONF.benchmark.heat_stack_snapshot_timeout)
self.res_is.mock.assert_has_calls([mock.call("SNAPSHOT_COMPLETE")]) 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(), self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.snapshot_stack") "heat.snapshot_stack")
@@ -181,18 +179,22 @@ class HeatScenarioTestCase(test.ClientsTestCase):
scenario._restore_stack(self.stack, "dummy_id") scenario._restore_stack(self.stack, "dummy_id")
self.clients("heat").stacks.restore.assert_called_once_with( self.clients("heat").stacks.restore.assert_called_once_with(
self.stack.id, "dummy_id") self.stack.id, "dummy_id")
self.wait_for.mock.assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.stack, self.stack,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.res_is.mock(), is_ready=self.mock_resource_is.mock.return_value,
check_interval=CONF.benchmark.heat_stack_restore_poll_interval, check_interval=CONF.benchmark.heat_stack_restore_poll_interval,
timeout=CONF.benchmark.heat_stack_restore_timeout) timeout=CONF.benchmark.heat_stack_restore_timeout)
self.res_is.mock.assert_has_calls([mock.call("RESTORE_COMPLETE")]) 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(), self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.restore_stack") "heat.restore_stack")
class HeatScenarioNegativeTestCase(test.ClientsTestCase): class HeatScenarioNegativeTestCase(test.ScenarioTestCase):
patch_benchmark_utils = False
def test_failed_create_stack(self): def test_failed_create_stack(self):
self.clients("heat").stacks.create.return_value = { self.clients("heat").stacks.create.return_value = {
"stack": {"id": "test_id"} "stack": {"id": "test_id"}
@@ -203,12 +205,9 @@ class HeatScenarioNegativeTestCase(test.ClientsTestCase):
stack.manager.get.return_value = resource stack.manager.get.return_value = resource
self.clients("heat").stacks.get.return_value = stack self.clients("heat").stacks.get.return_value = stack
scenario = utils.HeatScenario() scenario = utils.HeatScenario()
try: ex = self.assertRaises(exceptions.GetResourceErrorStatus,
ex = self.assertRaises(exceptions.GetResourceErrorStatus, scenario._create_stack, "stack_name")
scenario._create_stack, "stack_name") self.assertIn("has CREATE_FAILED status", str(ex))
self.assertIn("has CREATE_FAILED status", str(ex))
except exceptions.TimeoutException:
raise self.fail("Unrecognized error status")
def test_failed_update_stack(self): def test_failed_update_stack(self):
stack = mock.Mock() stack = mock.Mock()
@@ -217,10 +216,7 @@ class HeatScenarioNegativeTestCase(test.ClientsTestCase):
stack.manager.get.return_value = resource stack.manager.get.return_value = resource
self.clients("heat").stacks.get.return_value = stack self.clients("heat").stacks.get.return_value = stack
scenario = utils.HeatScenario() scenario = utils.HeatScenario()
try: ex = self.assertRaises(exceptions.GetResourceErrorStatus,
ex = self.assertRaises(exceptions.GetResourceErrorStatus, scenario._update_stack, stack,
scenario._update_stack, stack, "heat_template_version: 2013-05-23")
"heat_template_version: 2013-05-23") self.assertIn("has UPDATE_FAILED status", str(ex))
self.assertIn("has UPDATE_FAILED status", str(ex))
except exceptions.TimeoutException:
raise self.fail("Unrecognized error status")

2
tests/unit/plugins/openstack/scenarios/keystone/test_utils.py
View File

@@ -45,7 +45,7 @@ class KeystoneUtilsTestCase(test.TestCase):
self.assertEqual(utils.is_temporary(resource), is_valid) self.assertEqual(utils.is_temporary(resource), is_valid)
class KeystoneScenarioTestCase(test.ClientsTestCase): class KeystoneScenarioTestCase(test.ScenarioTestCase):
@mock.patch(UTILS + "uuid.uuid4", return_value="pwd") @mock.patch(UTILS + "uuid.uuid4", return_value="pwd")
@mock.patch("rally.common.utils.generate_random_name", @mock.patch("rally.common.utils.generate_random_name",

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

@@ -23,7 +23,7 @@ BM_UTILS = "rally.task.utils."
@ddt.ddt @ddt.ddt
class ManilaScenarioTestCase(test.ClientsTestCase): class ManilaScenarioTestCase(test.ScenarioTestCase):
def setUp(self): def setUp(self):
super(ManilaScenarioTestCase, self).setUp() super(ManilaScenarioTestCase, self).setUp()

2
tests/unit/plugins/openstack/scenarios/mistral/test_utils.py
View File

@@ -19,7 +19,7 @@ from tests.unit import test
MISTRAL_UTILS = "rally.plugins.openstack.scenarios.mistral.utils" MISTRAL_UTILS = "rally.plugins.openstack.scenarios.mistral.utils"
class MistralScenarioTestCase(test.ClientsTestCase): class MistralScenarioTestCase(test.ScenarioTestCase):
def test_list_workbooks(self): def test_list_workbooks(self):
scenario = utils.MistralScenario() scenario = utils.MistralScenario()

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

@@ -14,30 +14,16 @@
# under the License. # under the License.
import mock import mock
from oslotest import mockpatch from oslo_config import cfg
from rally.plugins.openstack.scenarios.murano import utils from rally.plugins.openstack.scenarios.murano import utils
from tests.unit import test from tests.unit import test
BM_UTILS = "rally.task.utils"
MRN_UTILS = "rally.plugins.openstack.scenarios.murano.utils" MRN_UTILS = "rally.plugins.openstack.scenarios.murano.utils"
CONF = cfg.CONF
class MuranoScenarioTestCase(test.ClientsTestCase): class MuranoScenarioTestCase(test.ScenarioTestCase):
def setUp(self):
super(MuranoScenarioTestCase, self).setUp()
self.res_is = mockpatch.Patch(BM_UTILS + ".resource_is")
self.get_fm = mockpatch.Patch(BM_UTILS + ".get_from_manager")
self.wait_for = mockpatch.Patch(MRN_UTILS + ".utils.wait_for")
self.wait_for_delete = mockpatch.Patch(
MRN_UTILS + ".utils.wait_for_delete")
self.useFixture(self.wait_for)
self.useFixture(self.wait_for_delete)
self.useFixture(self.res_is)
self.useFixture(self.get_fm)
self.gfm = self.get_fm.mock
self.useFixture(mockpatch.Patch("time.sleep"))
def test_list_environments(self): def test_list_environments(self):
self.clients("murano").environments.list.return_value = [] self.clients("murano").environments.list.return_value = []
@@ -66,11 +52,12 @@ class MuranoScenarioTestCase(test.ClientsTestCase):
environment.id environment.id
) )
self.wait_for_delete.mock.assert_called_once_with( self.mock_wait_for_delete.mock.assert_called_once_with(
environment, environment,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
timeout=180, timeout=CONF.benchmark.delete_environment_timeout,
check_interval=2) check_interval=CONF.benchmark.delete_environment_check_interval)
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(scenario.atomic_actions(), self._test_atomic_action_timer(scenario.atomic_actions(),
"murano.delete_environment") "murano.delete_environment")
@@ -107,11 +94,14 @@ class MuranoScenarioTestCase(test.ClientsTestCase):
environment.id, session.id environment.id, session.id
) )
self.wait_for.mock.assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
environment, environment,
update_resource=self.gfm(), update_resource=self.mock_get_from_manager.mock.return_value,
is_ready=self.res_is.mock(), is_ready=self.mock_resource_is.mock.return_value,
check_interval=5.0, check_interval=CONF.benchmark.deploy_environment_check_interval,
timeout=1200.0) timeout=CONF.benchmark.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(), self._test_atomic_action_timer(scenario.atomic_actions(),
"murano.deploy_environment") "murano.deploy_environment")

2
tests/unit/plugins/openstack/scenarios/neutron/test_network.py
View File

@@ -22,7 +22,7 @@ NEUTRON_NETWORKS = ("rally.plugins.openstack.scenarios.neutron.network"
".NeutronNetworks") ".NeutronNetworks")
class NeutronNetworksTestCase(test.ClientsTestCase): class NeutronNetworksTestCase(test.ScenarioTestCase):
@mock.patch(NEUTRON_NETWORKS + "._list_networks") @mock.patch(NEUTRON_NETWORKS + "._list_networks")
@mock.patch(NEUTRON_NETWORKS + "._create_network") @mock.patch(NEUTRON_NETWORKS + "._create_network")

4
tests/unit/plugins/openstack/scenarios/neutron/test_utils.py
View File

@@ -22,7 +22,7 @@ from tests.unit import test
NEUTRON_UTILS = "rally.plugins.openstack.scenarios.neutron.utils." NEUTRON_UTILS = "rally.plugins.openstack.scenarios.neutron.utils."
class NeutronScenarioTestCase(test.ClientsTestCase): class NeutronScenarioTestCase(test.ScenarioTestCase):
def setUp(self): def setUp(self):
super(NeutronScenarioTestCase, self).setUp() super(NeutronScenarioTestCase, self).setUp()
@@ -469,7 +469,7 @@ class NeutronScenarioTestCase(test.ClientsTestCase):
"neutron.list_pools") "neutron.list_pools")
class NeutronScenarioFunctionalTestCase(test.FakeClientsTestCase): class NeutronScenarioFunctionalTestCase(test.FakeClientsScenarioTestCase):
@mock.patch(NEUTRON_UTILS + "network_wrapper.generate_cidr") @mock.patch(NEUTRON_UTILS + "network_wrapper.generate_cidr")
def test_functional_create_network_and_subnets(self, mock_generate_cidr): def test_functional_create_network_and_subnets(self, mock_generate_cidr):

2
tests/unit/plugins/openstack/scenarios/nova/test_servers.py
View File

@@ -25,7 +25,7 @@ NOVA_SERVERS_MODULE = "rally.plugins.openstack.scenarios.nova.servers"
NOVA_SERVERS = NOVA_SERVERS_MODULE + ".NovaServers" NOVA_SERVERS = NOVA_SERVERS_MODULE + ".NovaServers"
class NovaServersTestCase(test.ClientsTestCase): class NovaServersTestCase(test.ScenarioTestCase):
def test_boot_rescue_unrescue(self): def test_boot_rescue_unrescue(self):
actions = [{"rescue_unrescue": 5}] actions = [{"rescue_unrescue": 5}]

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

@@ -15,7 +15,6 @@
import mock import mock
from oslo_config import cfg from oslo_config import cfg
from oslotest import mockpatch
from rally import exceptions as rally_exceptions from rally import exceptions as rally_exceptions
from rally.plugins.openstack.scenarios.nova import utils from rally.plugins.openstack.scenarios.nova import utils
@@ -27,7 +26,7 @@ NOVA_UTILS = "rally.plugins.openstack.scenarios.nova.utils"
CONF = cfg.CONF CONF = cfg.CONF
class NovaScenarioTestCase(test.ClientsTestCase): class NovaScenarioTestCase(test.ScenarioTestCase):
def setUp(self): def setUp(self):
super(NovaScenarioTestCase, self).setUp() super(NovaScenarioTestCase, self).setUp()
@@ -37,45 +36,6 @@ class NovaScenarioTestCase(test.ClientsTestCase):
self.floating_ip = mock.Mock() self.floating_ip = mock.Mock()
self.image = mock.Mock() self.image = mock.Mock()
self.keypair = mock.Mock() self.keypair = mock.Mock()
self.res_is = mockpatch.Patch(BM_UTILS + ".resource_is")
self.get_fm = mockpatch.Patch(BM_UTILS + ".get_from_manager")
self.wait_for = mockpatch.Patch(NOVA_UTILS + ".utils.wait_for")
self.wait_for_delete = mockpatch.Patch(NOVA_UTILS +
".utils.wait_for_delete")
self.useFixture(self.wait_for_delete)
self.useFixture(self.wait_for)
self.useFixture(self.res_is)
self.useFixture(self.get_fm)
self.gfm = self.get_fm.mock
self.useFixture(mockpatch.Patch("time.sleep"))
def _test_assert_called_once_with(self, mock, resource,
chk_interval, time_out, **kwargs):
"""Method to replace repeatative asserts on resources
:param mock: The mock to call assert with
:param resource: The resource used in mock
:param chk_interval: The interval used for polling the action
:param time_out: Time out value for action
:param kwargs: currently used for validating the is_ready attribute,
can be extended as required
"""
isready = self.res_is.mock()
if kwargs:
if kwargs["is_ready"]:
mock.assert_called_once_with(
resource,
update_resource=self.gfm(),
is_ready=isready,
check_interval=chk_interval,
timeout=time_out)
else:
mock.assert_called_once_with(
resource,
update_resource=self.gfm(),
check_interval=chk_interval,
timeout=time_out)
def test__list_servers(self): def test__list_servers(self):
servers_list = [] servers_list = []
@@ -93,12 +53,15 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario = utils.NovaScenario(context={}) nova_scenario = utils.NovaScenario(context={})
return_server = nova_scenario._boot_server("image_id", return_server = nova_scenario._boot_server("image_id",
"flavor_id") "flavor_id")
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_boot_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_boot_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) check_interval=CONF.benchmark.nova_server_boot_poll_interval,
self.assertEqual(self.wait_for.mock(), return_server) 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)
self.clients("nova").servers.create.assert_called_once_with( self.clients("nova").servers.create.assert_called_once_with(
"foo_server_name", "image_id", "flavor_id") "foo_server_name", "image_id", "flavor_id")
self._test_atomic_action_timer(nova_scenario.atomic_actions(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
@@ -118,15 +81,18 @@ class NovaScenarioTestCase(test.ClientsTestCase):
return_server = nova_scenario._boot_server("image_id", return_server = nova_scenario._boot_server("image_id",
"flavor_id", "flavor_id",
auto_assign_nic=True) auto_assign_nic=True)
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_boot_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_boot_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) 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.clients("nova").servers.create.assert_called_once_with( self.clients("nova").servers.create.assert_called_once_with(
"foo_server_name", "image_id", "flavor_id", "foo_server_name", "image_id", "flavor_id",
nics=[{"net-id": "bar_id"}]) nics=[{"net-id": "bar_id"}])
self.assertEqual(self.wait_for.mock(), return_server) self.assertEqual(self.mock_wait_for.mock.return_value, return_server)
self._test_atomic_action_timer(nova_scenario.atomic_actions(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.boot_server") "nova.boot_server")
@@ -146,12 +112,15 @@ class NovaScenarioTestCase(test.ClientsTestCase):
"user": {"secgroup": {"name": "test"}}} "user": {"secgroup": {"name": "test"}}}
) )
return_server = nova_scenario._boot_server("image_id", "flavor_id") return_server = nova_scenario._boot_server("image_id", "flavor_id")
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_boot_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_boot_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) check_interval=CONF.benchmark.nova_server_boot_poll_interval,
self.assertEqual(self.wait_for.mock(), return_server) 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)
self.clients("nova").servers.create.assert_called_once_with( self.clients("nova").servers.create.assert_called_once_with(
"foo_server_name", "image_id", "flavor_id", "foo_server_name", "image_id", "flavor_id",
security_groups=["test"]) security_groups=["test"])
@@ -168,12 +137,15 @@ class NovaScenarioTestCase(test.ClientsTestCase):
return_server = nova_scenario._boot_server( return_server = nova_scenario._boot_server(
"image_id", "flavor_id", "image_id", "flavor_id",
security_groups=["test"]) security_groups=["test"])
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_boot_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_boot_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) check_interval=CONF.benchmark.nova_server_boot_poll_interval,
self.assertEqual(self.wait_for.mock(), return_server) 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)
self.clients("nova").servers.create.assert_called_once_with( self.clients("nova").servers.create.assert_called_once_with(
"foo_server_name", "image_id", "flavor_id", "foo_server_name", "image_id", "flavor_id",
security_groups=["test", "new"]) security_groups=["test", "new"])
@@ -191,12 +163,15 @@ class NovaScenarioTestCase(test.ClientsTestCase):
return_server = nova_scenario._boot_server( return_server = nova_scenario._boot_server(
"image_id", "flavor_id", "image_id", "flavor_id",
security_groups=["test1"]) security_groups=["test1"])
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_boot_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_boot_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) check_interval=CONF.benchmark.nova_server_boot_poll_interval,
self.assertEqual(self.wait_for.mock(), return_server) 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)
self.clients("nova").servers.create.assert_called_once_with( self.clients("nova").servers.create.assert_called_once_with(
"foo_server_name", "image_id", "flavor_id", "foo_server_name", "image_id", "flavor_id",
security_groups=["test1"]) security_groups=["test1"])
@@ -207,11 +182,14 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
nova_scenario._suspend_server(self.server) nova_scenario._suspend_server(self.server)
self.server.suspend.assert_called_once_with() self.server.suspend.assert_called_once_with()
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_suspend_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_suspend_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("SUSPENDED")]) 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(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.suspend_server") "nova.suspend_server")
@@ -219,11 +197,14 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
nova_scenario._resume_server(self.server) nova_scenario._resume_server(self.server)
self.server.resume.assert_called_once_with() self.server.resume.assert_called_once_with()
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_resume_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_resume_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) 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(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.resume_server") "nova.resume_server")
@@ -231,11 +212,14 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
nova_scenario._pause_server(self.server) nova_scenario._pause_server(self.server)
self.server.pause.assert_called_once_with() self.server.pause.assert_called_once_with()
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_pause_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_pause_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("PAUSED")]) 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(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.pause_server") "nova.pause_server")
@@ -243,11 +227,14 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
nova_scenario._unpause_server(self.server) nova_scenario._unpause_server(self.server)
self.server.unpause.assert_called_once_with() self.server.unpause.assert_called_once_with()
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_unpause_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_unpause_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) 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(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.unpause_server") "nova.unpause_server")
@@ -255,11 +242,14 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
nova_scenario._shelve_server(self.server) nova_scenario._shelve_server(self.server)
self.server.shelve.assert_called_once_with() self.server.shelve.assert_called_once_with()
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_shelve_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_shelve_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("SHELVED_OFFLOADED")]) 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(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.shelve_server") "nova.shelve_server")
@@ -267,11 +257,14 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
nova_scenario._unshelve_server(self.server) nova_scenario._unshelve_server(self.server)
self.server.unshelve.assert_called_once_with() self.server.unshelve.assert_called_once_with()
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_unshelve_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_unshelve_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) 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(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.unshelve_server") "nova.unshelve_server")
@@ -279,12 +272,16 @@ class NovaScenarioTestCase(test.ClientsTestCase):
self.clients("nova").images.get.return_value = self.image self.clients("nova").images.get.return_value = self.image
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
return_image = nova_scenario._create_image(self.server) return_image = nova_scenario._create_image(self.server)
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.image, self.image,
CONF.benchmark.nova_server_image_create_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_image_create_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) check_interval=CONF.benchmark.
self.assertEqual(self.wait_for.mock(), return_image) 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(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.create_image") "nova.create_image")
@@ -292,11 +289,12 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
nova_scenario._delete_server(self.server) nova_scenario._delete_server(self.server)
self.server.delete.assert_called_once_with() self.server.delete.assert_called_once_with()
self._test_assert_called_once_with( self.mock_wait_for_delete.mock.assert_called_once_with(
self.wait_for_delete.mock, self.server, self.server,
CONF.benchmark.nova_server_delete_poll_interval, update_resource=self.mock_get_from_manager.mock.return_value,
CONF.benchmark.nova_server_delete_timeout, check_interval=CONF.benchmark.nova_server_delete_poll_interval,
is_ready=None) timeout=CONF.benchmark.nova_server_delete_timeout)
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.delete_server") "nova.delete_server")
@@ -304,11 +302,12 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
nova_scenario._delete_server(self.server, force=True) nova_scenario._delete_server(self.server, force=True)
self.server.force_delete.assert_called_once_with() self.server.force_delete.assert_called_once_with()
self._test_assert_called_once_with( self.mock_wait_for_delete.mock.assert_called_once_with(
self.wait_for_delete.mock, self.server, self.server,
CONF.benchmark.nova_server_delete_poll_interval, update_resource=self.mock_get_from_manager.mock.return_value,
CONF.benchmark.nova_server_delete_timeout, check_interval=CONF.benchmark.nova_server_delete_poll_interval,
is_ready=None) timeout=CONF.benchmark.nova_server_delete_timeout)
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.force_delete_server") "nova.force_delete_server")
@@ -316,11 +315,14 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
nova_scenario._reboot_server(self.server) nova_scenario._reboot_server(self.server)
self.server.reboot.assert_called_once_with(reboot_type="HARD") self.server.reboot.assert_called_once_with(reboot_type="HARD")
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_reboot_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_reboot_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) 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(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.reboot_server") "nova.reboot_server")
@@ -328,11 +330,14 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
nova_scenario._soft_reboot_server(self.server) nova_scenario._soft_reboot_server(self.server)
self.server.reboot.assert_called_once_with(reboot_type="SOFT") self.server.reboot.assert_called_once_with(reboot_type="SOFT")
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_reboot_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_reboot_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) 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(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.soft_reboot_server") "nova.soft_reboot_server")
@@ -340,11 +345,14 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
nova_scenario._rebuild_server(self.server, "img", fakearg="fakearg") nova_scenario._rebuild_server(self.server, "img", fakearg="fakearg")
self.server.rebuild.assert_called_once_with("img", fakearg="fakearg") self.server.rebuild.assert_called_once_with("img", fakearg="fakearg")
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_rebuild_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_rebuild_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) 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(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.rebuild_server") "nova.rebuild_server")
@@ -352,11 +360,14 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
nova_scenario._start_server(self.server) nova_scenario._start_server(self.server)
self.server.start.assert_called_once_with() self.server.start.assert_called_once_with()
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_start_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_start_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) 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(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.start_server") "nova.start_server")
@@ -364,11 +375,14 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
nova_scenario._stop_server(self.server) nova_scenario._stop_server(self.server)
self.server.stop.assert_called_once_with() self.server.stop.assert_called_once_with()
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_stop_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_stop_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("SHUTOFF")]) 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(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.stop_server") "nova.stop_server")
@@ -376,11 +390,14 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
nova_scenario._rescue_server(self.server) nova_scenario._rescue_server(self.server)
self.server.rescue.assert_called_once_with() self.server.rescue.assert_called_once_with()
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_rescue_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_rescue_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("RESCUE")]) 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(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.rescue_server") "nova.rescue_server")
@@ -388,11 +405,14 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
nova_scenario._unrescue_server(self.server) nova_scenario._unrescue_server(self.server)
self.server.unrescue.assert_called_once_with() self.server.unrescue.assert_called_once_with()
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_unrescue_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_unrescue_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) 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(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.unrescue_server") "nova.unrescue_server")
@@ -404,7 +424,8 @@ class NovaScenarioTestCase(test.ClientsTestCase):
expected = [] expected = []
for server in servers: for server in servers:
expected.append(mock.call( expected.append(mock.call(
server, update_resource=self.gfm(), server,
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=check_interval, check_interval=check_interval,
timeout=CONF.benchmark.nova_server_delete_timeout)) timeout=CONF.benchmark.nova_server_delete_timeout))
if force: if force:
@@ -414,7 +435,7 @@ class NovaScenarioTestCase(test.ClientsTestCase):
server.delete.assert_called_once_with() server.delete.assert_called_once_with()
self.assertFalse(server.force_delete.called) self.assertFalse(server.force_delete.called)
self.assertEqual(expected, self.wait_for_delete.mock.mock_calls) self.mock_wait_for_delete.mock.assert_has_calls(expected)
timer_name = "nova.%sdelete_servers" % ("force_" if force else "") timer_name = "nova.%sdelete_servers" % ("force_" if force else "")
self._test_atomic_action_timer(nova_scenario.atomic_actions(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
timer_name) timer_name)
@@ -429,11 +450,13 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
nova_scenario._delete_image(self.image) nova_scenario._delete_image(self.image)
self.image.delete.assert_called_once_with() self.image.delete.assert_called_once_with()
self._test_assert_called_once_with( self.mock_wait_for_delete.mock.assert_called_once_with(
self.wait_for_delete.mock, self.image, self.image,
CONF.benchmark.nova_server_image_delete_poll_interval, update_resource=self.mock_get_from_manager.mock.return_value,
CONF.benchmark.nova_server_image_delete_timeout, check_interval=CONF.benchmark.
is_ready=None) nova_server_image_delete_poll_interval,
timeout=CONF.benchmark.nova_server_image_delete_timeout)
self.mock_get_from_manager.mock.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.delete_image") "nova.delete_image")
@@ -444,20 +467,25 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario._boot_servers("image", "flavor", 2) nova_scenario._boot_servers("image", "flavor", 2)
expected = [ expected = [
mock.call( mock.call(
self.server, is_ready=self.res_is.mock(), self.server,
update_resource=self.gfm(), is_ready=self.mock_resource_is.mock.return_value,
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.nova_server_boot_poll_interval, check_interval=CONF.benchmark.nova_server_boot_poll_interval,
timeout=CONF.benchmark.nova_server_boot_timeout timeout=CONF.benchmark.nova_server_boot_timeout
), ),
mock.call( mock.call(
self.server1, is_ready=self.res_is.mock(), self.server1,
update_resource=self.gfm(), is_ready=self.mock_resource_is.mock.return_value,
update_resource=self.mock_get_from_manager.mock.return_value,
check_interval=CONF.benchmark.nova_server_boot_poll_interval, check_interval=CONF.benchmark.nova_server_boot_poll_interval,
timeout=CONF.benchmark.nova_server_boot_timeout timeout=CONF.benchmark.nova_server_boot_timeout
) )
] ]
self.assertEqual(expected, self.wait_for.mock.mock_calls) self.mock_wait_for.mock.assert_has_calls(expected)
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) self.mock_resource_is.mock.assert_has_calls([mock.call("ACTIVE"),
mock.call("ACTIVE")])
self.mock_get_from_manager.mock.assert_has_calls([mock.call(),
mock.call()])
self._test_atomic_action_timer(nova_scenario.atomic_actions(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.boot_servers") "nova.boot_servers")
@@ -559,11 +587,15 @@ class NovaScenarioTestCase(test.ClientsTestCase):
disk_over_commit=False, disk_over_commit=False,
skip_host_check=True) skip_host_check=True)
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, self.server, self.server,
CONF.benchmark.nova_server_live_migrate_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_live_migrate_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) 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(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.live_migrate") "nova.live_migrate")
@@ -596,11 +628,14 @@ class NovaScenarioTestCase(test.ClientsTestCase):
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
nova_scenario._migrate(fake_server, skip_host_check=True) nova_scenario._migrate(fake_server, skip_host_check=True)
self._test_assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
self.wait_for.mock, fake_server, fake_server,
CONF.benchmark.nova_server_migrate_poll_interval, is_ready=self.mock_resource_is.mock.return_value,
CONF.benchmark.nova_server_migrate_timeout) update_resource=self.mock_get_from_manager.mock.return_value,
self.res_is.mock.assert_has_calls([mock.call("VERIFY_RESIZE")]) 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(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.migrate") "nova.migrate")

2
tests/unit/plugins/openstack/scenarios/quotas/test_quotas.py
View File

@@ -19,7 +19,7 @@ from rally.plugins.openstack.scenarios.quotas import quotas
from tests.unit import test from tests.unit import test
class QuotasTestCase(test.ClientsTestCase): class QuotasTestCase(test.ScenarioTestCase):
def setUp(self): def setUp(self):
super(QuotasTestCase, self).setUp() super(QuotasTestCase, self).setUp()

2
tests/unit/plugins/openstack/scenarios/quotas/test_utils.py
View File

@@ -20,7 +20,7 @@ from rally.plugins.openstack.scenarios.quotas import utils
from tests.unit import test from tests.unit import test
class QuotasScenarioTestCase(test.ClientsTestCase): class QuotasScenarioTestCase(test.ScenarioTestCase):
def test__update_quotas(self): def test__update_quotas(self):
tenant_id = "fake_tenant" tenant_id = "fake_tenant"

2
tests/unit/plugins/openstack/scenarios/sahara/test_clusters.py
View File

@@ -23,7 +23,7 @@ SAHARA_CLUSTERS = ("rally.plugins.openstack.scenarios.sahara.clusters"
SAHARA_UTILS = "rally.plugins.openstack.scenarios.sahara.utils" SAHARA_UTILS = "rally.plugins.openstack.scenarios.sahara.utils"
class SaharaClustersTestCase(test.ClientsTestCase): class SaharaClustersTestCase(test.ScenarioTestCase):
@mock.patch(SAHARA_CLUSTERS + "._delete_cluster") @mock.patch(SAHARA_CLUSTERS + "._delete_cluster")
@mock.patch(SAHARA_CLUSTERS + "._launch_cluster", @mock.patch(SAHARA_CLUSTERS + "._launch_cluster",

2
tests/unit/plugins/openstack/scenarios/sahara/test_jobs.py
View File

@@ -25,7 +25,7 @@ SAHARA_JOB = "rally.plugins.openstack.scenarios.sahara.jobs.SaharaJob"
SAHARA_UTILS = "rally.plugins.openstack.scenarios.sahara.utils" SAHARA_UTILS = "rally.plugins.openstack.scenarios.sahara.utils"
class SaharaJobTestCase(test.ClientsTestCase): class SaharaJobTestCase(test.ScenarioTestCase):
def setUp(self): def setUp(self):
super(SaharaJobTestCase, self).setUp() super(SaharaJobTestCase, self).setUp()

10
tests/unit/plugins/openstack/scenarios/sahara/test_utils.py
View File

@@ -28,7 +28,15 @@ CONF = cfg.CONF
SAHARA_UTILS = "rally.plugins.openstack.scenarios.sahara.utils" SAHARA_UTILS = "rally.plugins.openstack.scenarios.sahara.utils"
class SaharaScenarioTestCase(test.ClientsTestCase): class SaharaScenarioTestCase(test.ScenarioTestCase):
# NOTE(stpierre): the Sahara utils generally do funny stuff with
# wait_for() calls -- frequently the the is_ready and
# update_resource arguments are functions defined in the Sahara
# utils themselves instead of the more standard resource_is() and
# get_from_manager() calls. As a result, the tests below do more
# integrated/functional testing of wait_for() calls, and we can't
# just mock out wait_for and friends the way we usually do.
patch_benchmark_utils = False
def setUp(self): def setUp(self):
super(SaharaScenarioTestCase, self).setUp() super(SaharaScenarioTestCase, self).setUp()

2
tests/unit/plugins/openstack/scenarios/swift/test_objects.py
View File

@@ -19,7 +19,7 @@ from rally.plugins.openstack.scenarios.swift import objects
from tests.unit import test from tests.unit import test
class SwiftObjectsTestCase(test.ClientsTestCase): class SwiftObjectsTestCase(test.ScenarioTestCase):
def test_create_container_and_object_then_list_objects(self): def test_create_container_and_object_then_list_objects(self):
scenario = objects.SwiftObjects() scenario = objects.SwiftObjects()

2
tests/unit/plugins/openstack/scenarios/swift/test_utils.py
View File

@@ -21,7 +21,7 @@ from tests.unit import test
SWIFT_UTILS = "rally.plugins.openstack.scenarios.swift.utils" SWIFT_UTILS = "rally.plugins.openstack.scenarios.swift.utils"
class SwiftScenarioTestCase(test.ClientsTestCase): class SwiftScenarioTestCase(test.ScenarioTestCase):
def test__list_containers(self): def test__list_containers(self):
headers_dict = mock.MagicMock() headers_dict = mock.MagicMock()

24
tests/unit/plugins/openstack/scenarios/vm/test_utils.py
View File

@@ -18,7 +18,6 @@ import subprocess
import mock import mock
import netaddr import netaddr
from oslotest import mockpatch
from rally.plugins.openstack.scenarios.vm import utils from rally.plugins.openstack.scenarios.vm import utils
from tests.unit import test from tests.unit import test
@@ -26,13 +25,7 @@ from tests.unit import test
VMTASKS_UTILS = "rally.plugins.openstack.scenarios.vm.utils" VMTASKS_UTILS = "rally.plugins.openstack.scenarios.vm.utils"
class VMScenarioTestCase(test.TestCase): class VMScenarioTestCase(test.ScenarioTestCase):
def setUp(self):
super(VMScenarioTestCase, self).setUp()
self.wait_for = mockpatch.Patch(VMTASKS_UTILS +
".utils.wait_for")
self.useFixture(self.wait_for)
@mock.patch("%s.open" % VMTASKS_UTILS, @mock.patch("%s.open" % VMTASKS_UTILS,
side_effect=mock.mock_open(), create=True) side_effect=mock.mock_open(), create=True)
@@ -92,19 +85,16 @@ class VMScenarioTestCase(test.TestCase):
vm_scenario._wait_for_ssh(ssh) vm_scenario._wait_for_ssh(ssh)
ssh.wait.assert_called_once_with() ssh.wait.assert_called_once_with()
@mock.patch(VMTASKS_UTILS + ".utils.resource_is") def test__wait_for_ping(self):
@mock.patch(VMTASKS_UTILS + ".VMScenario._ping_ip_address",
return_value=True)
def test__wait_for_ping(self, mock_vm_scenario__ping_ip_address,
mock_resource_is):
vm_scenario = utils.VMScenario() vm_scenario = utils.VMScenario()
vm_scenario._ping_ip_address = mock.Mock(return_value=True)
vm_scenario._wait_for_ping(netaddr.IPAddress("1.2.3.4")) vm_scenario._wait_for_ping(netaddr.IPAddress("1.2.3.4"))
self.wait_for.mock.assert_called_once_with( self.mock_wait_for.mock.assert_called_once_with(
netaddr.IPAddress("1.2.3.4"), netaddr.IPAddress("1.2.3.4"),
is_ready=mock_resource_is.return_value, is_ready=self.mock_resource_is.mock.return_value,
timeout=120) timeout=120)
mock_resource_is.assert_called_once_with( self.mock_resource_is.mock.assert_called_once_with(
"ICMP UP", mock_vm_scenario__ping_ip_address) "ICMP UP", vm_scenario._ping_ip_address)
@mock.patch(VMTASKS_UTILS + ".VMScenario._run_command_over_ssh") @mock.patch(VMTASKS_UTILS + ".VMScenario._run_command_over_ssh")
@mock.patch("rally.common.sshutils.SSH") @mock.patch("rally.common.sshutils.SSH")

2
tests/unit/plugins/openstack/scenarios/zaqar/test_utils.py
View File

@@ -21,7 +21,7 @@ from tests.unit import test
UTILS = "rally.plugins.openstack.scenarios.zaqar.utils." UTILS = "rally.plugins.openstack.scenarios.zaqar.utils."
class ZaqarScenarioTestCase(test.ClientsTestCase): class ZaqarScenarioTestCase(test.ScenarioTestCase):
@mock.patch(UTILS + "ZaqarScenario._generate_random_name", @mock.patch(UTILS + "ZaqarScenario._generate_random_name",
return_value="kitkat") return_value="kitkat")

30
tests/unit/test.py
View File

@@ -18,6 +18,7 @@ import os
import mock import mock
from oslo_config import fixture from oslo_config import fixture
from oslotest import base from oslotest import base
from oslotest import mockpatch
from rally import db from rally import db
from tests.unit import fakes from tests.unit import fakes
@@ -58,8 +59,10 @@ class DBTestCase(TestCase):
self.useFixture(DatabaseFixture()) self.useFixture(DatabaseFixture())
class ClientsTestCase(TestCase): class ScenarioTestCase(TestCase):
"""Base class for Scenario tests using mocked self.clients.""" """Base class for Scenario tests using mocked self.clients."""
benchmark_utils = "rally.task.utils"
patch_benchmark_utils = True
def client_factory(self, client_type, version=None, admin=False): def client_factory(self, client_type, version=None, admin=False):
"""Create a new client object.""" """Create a new client object."""
@@ -91,7 +94,24 @@ class ClientsTestCase(TestCase):
return key in self._clients return key in self._clients
def setUp(self): def setUp(self):
super(ClientsTestCase, self).setUp() super(ScenarioTestCase, self).setUp()
if self.patch_benchmark_utils:
self.mock_resource_is = mockpatch.Patch(
self.benchmark_utils + ".resource_is")
self.mock_get_from_manager = mockpatch.Patch(
self.benchmark_utils + ".get_from_manager")
self.mock_wait_for = mockpatch.Patch(
self.benchmark_utils + ".wait_for")
self.mock_wait_for_delete = mockpatch.Patch(
self.benchmark_utils + ".wait_for_delete")
self.useFixture(self.mock_resource_is)
self.useFixture(self.mock_get_from_manager)
self.useFixture(self.mock_wait_for)
self.useFixture(self.mock_wait_for_delete)
self.mock_sleep = mockpatch.Patch("time.sleep")
self.useFixture(self.mock_sleep)
self._clients = {} self._clients = {}
self._client_mocks = [ self._client_mocks = [
mock.patch("rally.task.scenarios.base.Scenario.clients", mock.patch("rally.task.scenarios.base.Scenario.clients",
@@ -105,15 +125,15 @@ class ClientsTestCase(TestCase):
def tearDown(self): def tearDown(self):
for patcher in self._client_mocks: for patcher in self._client_mocks:
patcher.stop() patcher.stop()
super(ClientsTestCase, self).tearDown() super(ScenarioTestCase, self).tearDown()
class FakeClientsTestCase(ClientsTestCase): class FakeClientsScenarioTestCase(ScenarioTestCase):
"""Base class for Scenario tests using fake (not mocked) self.clients.""" """Base class for Scenario tests using fake (not mocked) self.clients."""
def client_factory(self, client_type, version=None, admin=False): def client_factory(self, client_type, version=None, admin=False):
return getattr(self._fake_clients, client_type)() return getattr(self._fake_clients, client_type)()
def setUp(self): def setUp(self):
super(FakeClientsTestCase, self).setUp() super(FakeClientsScenarioTestCase, self).setUp()
self._fake_clients = fakes.FakeClients() self._fake_clients = fakes.FakeClients()