Merge "Better mocking for self.[admin_]clients in Scenario tests"

This commit is contained in:
Jenkins 2015-06-11 00:29:13 +00:00 committed by Gerrit Code Review
commit a9aa76ca12
28 changed files with 559 additions and 846 deletions

View File

@ -13,8 +13,6 @@
# License for the specific language governing permissions and limitations
# under the License.
import mock
from rally.benchmark.scenarios import base
from rally.plugins.openstack.scenarios.authenticate import authenticate
from tests.unit import test
@ -24,55 +22,43 @@ AUTHENTICATE_MODULE = (
"rally.plugins.openstack.scenarios.authenticate.authenticate")
class AuthenticateTestCase(test.TestCase):
class AuthenticateTestCase(test.ClientsTestCase):
@mock.patch(AUTHENTICATE_MODULE + ".Authenticate.clients")
def test_keystone(self, mock_clients):
def test_keystone(self):
scenario = authenticate.Authenticate()
scenario.keystone()
mock_clients.assert_called_once_with("keystone")
self.assertTrue(self.client_created("keystone"))
@mock.patch(AUTHENTICATE_MODULE + ".Authenticate.clients")
def test_validate_glance(self, mock_clients):
def test_validate_glance(self):
scenario = authenticate.Authenticate()
mock_clients.return_value.images.list = mock.MagicMock()
image_name = "__intentionally_non_existent_image___"
with base.AtomicAction(scenario, "authenticate.validate_glance"):
scenario.validate_glance(5)
mock_clients.return_value.images.list.assert_called_with(
name=image_name)
self.assertEqual(mock_clients.return_value.images.list.call_count, 5)
self.clients("glance").images.list.assert_called_with(name=image_name)
self.assertEqual(self.clients("glance").images.list.call_count, 5)
@mock.patch(AUTHENTICATE_MODULE + ".Authenticate.clients")
def test_validate_nova(self, mock_clients):
def test_validate_nova(self):
scenario = authenticate.Authenticate()
mock_clients.return_value.flavors.list = mock.MagicMock()
with base.AtomicAction(scenario, "authenticate.validate_nova"):
scenario.validate_nova(5)
self.assertEqual(mock_clients.return_value.flavors.list.call_count, 5)
self.assertEqual(self.clients("nova").flavors.list.call_count, 5)
@mock.patch(AUTHENTICATE_MODULE + ".Authenticate.clients")
def test_validate_cinder(self, mock_clients):
def test_validate_cinder(self):
scenario = authenticate.Authenticate()
mock_clients.return_value.volume_types.list = mock.MagicMock()
with base.AtomicAction(scenario, "authenticate.validate_cinder"):
scenario.validate_cinder(5)
self.assertEqual(mock_clients.return_value.volume_types.
list.call_count, 5)
self.assertEqual(self.clients("cinder").volume_types.list.call_count,
5)
@mock.patch(AUTHENTICATE_MODULE + ".Authenticate.clients")
def test_validate_neutron(self, mock_clients):
def test_validate_neutron(self):
scenario = authenticate.Authenticate()
mock_clients.return_value.get_auth_info = mock.MagicMock()
with base.AtomicAction(scenario, "authenticate.validate_neutron"):
scenario.validate_neutron(5)
self.assertEqual(mock_clients.return_value.get_auth_info.call_count, 5)
self.assertEqual(self.clients("neutron").get_auth_info.call_count, 5)
@mock.patch(AUTHENTICATE_MODULE + ".Authenticate.clients")
def test_validate_heat(self, mock_clients):
def test_validate_heat(self):
scenario = authenticate.Authenticate()
mock_clients.return_value.stacks.list = mock.MagicMock()
with base.AtomicAction(scenario, "authenticate.validate_heat"):
scenario.validate_heat(5)
mock_clients.return_value.stacks.list.assert_called_with(limit=0)
self.assertEqual(mock_clients.return_value.stacks.list.call_count, 5)
self.clients("heat").stacks.list.assert_called_with(limit=0)
self.assertEqual(self.clients("heat").stacks.list.call_count, 5)

View File

@ -23,7 +23,7 @@ BM_UTILS = "rally.benchmark.utils"
CEILOMETER_UTILS = "rally.plugins.openstack.scenarios.ceilometer.utils"
class CeilometerScenarioTestCase(test.TestCase):
class CeilometerScenarioTestCase(test.ClientsTestCase):
def setUp(self):
super(CeilometerScenarioTestCase, self).setUp()
self.scenario = utils.CeilometerScenario()
@ -92,10 +92,9 @@ class CeilometerScenarioTestCase(test.TestCase):
fake_state = self.scenario._get_alarm_state(fake_alarm.alarm_id)
self.assertEqual(fake_state, "alarm-state")
@mock.patch(CEILOMETER_UTILS + ".CeilometerScenario.clients")
def test__set_alarm_state(self, mock_clients):
def test__set_alarm_state(self):
alarm = mock.Mock()
mock_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)
self.wait_for.mock.assert_called_once_with(
alarm,

View File

@ -26,7 +26,7 @@ BM_UTILS = "rally.benchmark.utils"
CINDER_UTILS = "rally.plugins.openstack.scenarios.cinder.utils"
class CinderScenarioTestCase(test.TestCase):
class CinderScenarioTestCase(test.ClientsTestCase):
def setUp(self):
super(CinderScenarioTestCase, self).setUp()
@ -43,30 +43,26 @@ class CinderScenarioTestCase(test.TestCase):
self.useFixture(mockpatch.Patch("time.sleep"))
self.scenario = utils.CinderScenario()
@mock.patch(CINDER_UTILS + ".CinderScenario.clients")
def test__list_volumes(self, mock_clients):
volumes_list = mock.Mock()
mock_clients("cinder").volumes.list.return_value = volumes_list
def test__list_volumes(self):
return_volumes_list = self.scenario._list_volumes()
self.assertEqual(volumes_list, return_volumes_list)
self.assertEqual(self.clients("cinder").volumes.list.return_value,
return_volumes_list)
self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.list_volumes")
@mock.patch(CINDER_UTILS + ".CinderScenario.clients")
def test__list_snapshots(self, mock_clients):
snapsht_lst = mock.Mock()
mock_clients("cinder").volume_snapshots.list.return_value = snapsht_lst
def test__list_snapshots(self):
return_snapshots_list = self.scenario._list_snapshots()
self.assertEqual(snapsht_lst, return_snapshots_list)
self.assertEqual(
self.clients("cinder").volume_snapshots.list.return_value,
return_snapshots_list)
self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.list_snapshots")
@mock.patch(CINDER_UTILS + ".CinderScenario.clients")
def test__set_metadata(self, mock_clients):
def test__set_metadata(self):
volume = fakes.FakeVolume()
self.scenario._set_metadata(volume, sets=2, set_size=4)
calls = mock_clients("cinder").volumes.set_metadata.call_args_list
calls = self.clients("cinder").volumes.set_metadata.call_args_list
self.assertEqual(len(calls), 2)
for call in calls:
call_volume, metadata = call[0]
@ -76,13 +72,12 @@ class CinderScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.set_4_metadatas_2_times")
@mock.patch(CINDER_UTILS + ".CinderScenario.clients")
def test__delete_metadata(self, mock_clients):
def test__delete_metadata(self):
volume = fakes.FakeVolume()
keys = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"]
self.scenario._delete_metadata(volume, keys, deletes=3, delete_size=4)
calls = mock_clients("cinder").volumes.delete_metadata.call_args_list
calls = self.clients("cinder").volumes.delete_metadata.call_args_list
self.assertEqual(len(calls), 3)
all_deleted = []
for call in calls:
@ -97,8 +92,7 @@ class CinderScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.delete_4_metadatas_3_times")
@mock.patch(CINDER_UTILS + ".CinderScenario.clients")
def test__delete_metadata_not_enough_keys(self, mock_clients):
def test__delete_metadata_not_enough_keys(self):
volume = fakes.FakeVolume()
keys = ["a", "b", "c", "d", "e"]
@ -106,14 +100,11 @@ class CinderScenarioTestCase(test.TestCase):
self.scenario._delete_metadata,
volume, keys, deletes=2, delete_size=3)
@mock.patch(CINDER_UTILS + ".CinderScenario.clients")
def test__create_volume(self, mock_clients):
def test__create_volume(self):
CONF = cfg.CONF
volume = mock.Mock()
mock_clients("cinder").volumes.create.return_value = volume
return_volume = self.scenario._create_volume(1)
self.wait_for.mock.assert_called_once_with(
volume,
self.clients("cinder").volumes.create.return_value,
is_ready=self.res_is.mock(),
update_resource=self.gfm(),
timeout=CONF.benchmark.cinder_volume_create_timeout,
@ -125,22 +116,19 @@ class CinderScenarioTestCase(test.TestCase):
"cinder.create_volume")
@mock.patch("rally.plugins.openstack.scenarios.cinder.utils.random")
@mock.patch(CINDER_UTILS + ".CinderScenario.clients")
def test__create_volume_with_size_range(self, mock_clients, mock_random):
def test__create_volume_with_size_range(self, mock_random):
CONF = cfg.CONF
volume = mock.Mock()
mock_clients("cinder").volumes.create.return_value = volume
mock_random.randint.return_value = 3
return_volume = self.scenario._create_volume(
size={"min": 1, "max": 5},
display_name="TestVolume")
mock_clients("cinder").volumes.create.assert_called_once_with(
self.clients("cinder").volumes.create.assert_called_once_with(
3, display_name="TestVolume")
self.wait_for.mock.assert_called_once_with(
volume,
self.clients("cinder").volumes.create.return_value,
is_ready=self.res_is.mock(),
update_resource=self.gfm(),
timeout=CONF.benchmark.cinder_volume_create_timeout,
@ -165,12 +153,11 @@ class CinderScenarioTestCase(test.TestCase):
"cinder.delete_volume")
@mock.patch("rally.plugins.openstack.scenarios.cinder.utils.random")
@mock.patch(CINDER_UTILS + ".CinderScenario.clients")
def test__extend_volume_with_size_range(self, mock_clients, mock_random):
def test__extend_volume_with_size_range(self, mock_random):
CONF = cfg.CONF
volume = mock.Mock()
mock_random.randint.return_value = 3
mock_clients("cinder").volumes.extend.return_value = volume
self.clients("cinder").volumes.extend.return_value = volume
self.scenario._extend_volume(volume, new_size={"min": 1, "max": 5})
@ -186,11 +173,10 @@ class CinderScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.extend_volume")
@mock.patch(CINDER_UTILS + ".CinderScenario.clients")
def test__extend_volume(self, mock_clients):
def test__extend_volume(self):
CONF = cfg.CONF
volume = mock.Mock()
mock_clients("cinder").volumes.extend.return_value = volume
self.clients("cinder").volumes.extend.return_value = volume
self.scenario._extend_volume(volume, 2)
self.wait_for.mock.assert_called_once_with(
volume,
@ -203,12 +189,11 @@ class CinderScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.extend_volume")
@mock.patch(CINDER_UTILS + ".CinderScenario.clients")
def test__upload_volume_to_image(self, mock_clients):
def test__upload_volume_to_image(self):
volume = mock.Mock()
image = {"os-volume_upload_image": {"image_id": 1}}
volume.upload_to_image.return_value = (None, image)
mock_clients("cinder").images.get.return_value = image
self.clients("cinder").images.get.return_value = image
self.scenario._generate_random_name = mock.Mock(
return_value="test_vol")
@ -220,15 +205,11 @@ class CinderScenarioTestCase(test.TestCase):
self.assertTrue(self.wait_for.mock.called)
self.assertEqual(2, self.wait_for.mock.call_count)
@mock.patch(CINDER_UTILS + ".CinderScenario.clients")
def test__create_snapshot(self, mock_clients):
snapshot = mock.Mock()
mock_clients("cinder").volume_snapshots.create.return_value = snapshot
def test__create_snapshot(self):
return_snapshot = self.scenario._create_snapshot("uuid", False)
self.wait_for.mock.assert_called_once_with(
snapshot,
self.clients("cinder").volume_snapshots.create.return_value,
is_ready=self.res_is.mock(),
update_resource=self.gfm(),
timeout=cfg.CONF.benchmark.cinder_volume_create_timeout,
@ -252,15 +233,11 @@ class CinderScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.delete_snapshot")
@mock.patch(CINDER_UTILS + ".CinderScenario.clients")
def test__create_backup(self, mock_clients):
backup = mock.Mock()
mock_clients("cinder").backups.create.return_value = backup
def test__create_backup(self):
return_backup = self.scenario._create_backup("uuid")
self.wait_for.mock.assert_called_once_with(
backup,
self.clients("cinder").backups.create.return_value,
is_ready=self.res_is.mock(),
update_resource=self.gfm(),
timeout=cfg.CONF.benchmark.cinder_volume_create_timeout,
@ -284,12 +261,11 @@ class CinderScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.delete_backup")
@mock.patch(CINDER_UTILS + ".CinderScenario.clients")
def test__restore_backup(self, mock_clients):
def test__restore_backup(self):
backup = mock.Mock()
restore = mock.Mock()
mock_clients("cinder").restores.restore.return_value = backup
mock_clients("cinder").volumes.get.return_value = restore
self.clients("cinder").restores.restore.return_value = backup
self.clients("cinder").volumes.get.return_value = restore
return_restore = self.scenario._restore_backup(backup.id, None)

View File

@ -16,7 +16,6 @@
import mock
from rally.plugins.openstack.scenarios.cinder import volumes
from tests.unit import fakes
from tests.unit import test
CINDER_VOLUMES = ("rally.plugins.openstack.scenarios.cinder.volumes"
@ -27,7 +26,7 @@ class fake_type(object):
name = "fake"
class CinderServersTestCase(test.TestCase):
class CinderServersTestCase(test.ClientsTestCase):
def test_create_and_list_volume(self):
scenario = volumes.CinderVolumes()
@ -250,8 +249,7 @@ class CinderServersTestCase(test.TestCase):
scenario._create_snapshot = mock.MagicMock(return_value=fake_snapshot)
scenario._delete_snapshot = mock.MagicMock()
scenario.clients = mock.MagicMock()
scenario.clients("nova").servers.get = mock.MagicMock(
self.clients("nova").servers.get = mock.MagicMock(
return_value=fake_server)
scenario.create_snapshot_and_attach_volume()
@ -286,10 +284,9 @@ class CinderServersTestCase(test.TestCase):
scenario._delete_snapshot = mock.MagicMock()
fake = fake_type()
scenario.clients = mock.MagicMock()
scenario.clients("cinder").volume_types.list = mock.MagicMock(
self.clients("cinder").volume_types.list = mock.MagicMock(
return_value=[fake])
scenario.clients("nova").servers.get = mock.MagicMock(
self.clients("nova").servers.get = mock.MagicMock(
return_value=fake_server)
scenario.create_snapshot_and_attach_volume(volume_type=True)
@ -311,12 +308,8 @@ class CinderServersTestCase(test.TestCase):
def test_create_nested_snapshots_and_attach_volume(self):
fake_volume = mock.MagicMock()
fake_snapshot = mock.MagicMock()
fake_clients = fakes.FakeClients()
fake_server = fake_clients.nova().servers.create("test_server",
"image_id_01",
"flavor_id_01")
fake_server = mock.MagicMock()
scenario = volumes.CinderVolumes(
context={"user": {"tenant_id": "fake"},
"users": [{"tenant_id": "fake", "users_per_tenant": 1}],
"tenant": {"id": "fake", "name": "fake",
@ -330,8 +323,6 @@ class CinderServersTestCase(test.TestCase):
scenario._create_snapshot = mock.MagicMock(return_value=fake_snapshot)
scenario._delete_snapshot = mock.MagicMock()
scenario._clients = fake_clients
scenario.create_nested_snapshots_and_attach_volume()
volume_count = scenario._create_volume.call_count
@ -347,12 +338,9 @@ class CinderServersTestCase(test.TestCase):
fake_volume2 = mock.MagicMock()
fake_snapshot1 = mock.MagicMock()
fake_snapshot2 = mock.MagicMock()
fake_clients = fakes.FakeClients()
fake_server = fake_clients.nova().servers.create("test_server",
"image_id_01",
"flavor_id_01")
scenario = volumes.CinderVolumes(
fake_server = mock.MagicMock()
scenario = volumes.CinderVolumes(
context={"user": {"tenant_id": "fake"},
"users": [{"tenant_id": "fake", "users_per_tenant": 1}],
"tenant": {"id": "fake", "name": "fake",
@ -367,7 +355,6 @@ class CinderServersTestCase(test.TestCase):
scenario._create_snapshot = mock.MagicMock(
side_effect=[fake_snapshot1, fake_snapshot2])
scenario._delete_snapshot = mock.MagicMock()
scenario._clients = fake_clients
scenario.create_nested_snapshots_and_attach_volume(
nested_level={"min": 2, "max": 2})
@ -384,12 +371,9 @@ class CinderServersTestCase(test.TestCase):
mock_random.randint.return_value = 3
fake_volume = mock.MagicMock()
fake_snapshot = mock.MagicMock()
fake_clients = fakes.FakeClients()
fake_server = fake_clients.nova().servers.create("test_server",
"image_id_01",
"flavor_id_01")
scenario = volumes.CinderVolumes(
fake_server = mock.MagicMock()
scenario = volumes.CinderVolumes(
context={"user": {"tenant_id": "fake"},
"users": [{"tenant_id": "fake", "users_per_tenant": 1}],
"tenant": {"id": "fake", "name": "fake",
@ -403,7 +387,6 @@ class CinderServersTestCase(test.TestCase):
scenario._delete_volume = mock.MagicMock()
scenario._create_snapshot = mock.MagicMock(return_value=fake_snapshot)
scenario._delete_snapshot = mock.MagicMock()
scenario._clients = fake_clients
scenario.create_nested_snapshots_and_attach_volume()

View File

@ -22,7 +22,7 @@ from tests.unit import test
DESIGNATE_UTILS = "rally.plugins.openstack.scenarios.designate.utils."
class DesignateScenarioTestCase(test.TestCase):
class DesignateScenarioTestCase(test.ClientsTestCase):
def setUp(self):
super(DesignateScenarioTestCase, self).setUp()
@ -30,8 +30,7 @@ class DesignateScenarioTestCase(test.TestCase):
self.server = mock.Mock()
@mock.patch(DESIGNATE_UTILS + "DesignateScenario._generate_random_name")
@mock.patch(DESIGNATE_UTILS + "DesignateScenario.clients")
def test_create_domain(self, mock_clients, mock_random_name):
def test_create_domain(self, mock_random_name):
scenario = utils.DesignateScenario()
random_name = "foo"
@ -39,36 +38,33 @@ class DesignateScenarioTestCase(test.TestCase):
email = "root@zone.name"
mock_random_name.return_value = random_name
mock_clients("designate").domains.create.return_value = self.domain
self.clients("designate").domains.create.return_value = self.domain
# Check that the defaults / randoms are used if nothing is specified
domain = scenario._create_domain()
mock_clients("designate").domains.create.assert_called_once_with(
self.clients("designate").domains.create.assert_called_once_with(
{"email": "root@random.name", "name": "%s.name." % random_name})
self.assertEqual(self.domain, domain)
self._test_atomic_action_timer(scenario.atomic_actions(),
"designate.create_domain")
mock_clients("designate").domains.create.reset_mock()
self.clients("designate").domains.create.reset_mock()
# Check that when specifying zone defaults are not used...
data = {"email": email, "name": explicit_name}
domain = scenario._create_domain(data)
mock_clients("designate").domains.create.assert_called_once_with(data)
self.clients("designate").domains.create.assert_called_once_with(data)
self.assertEqual(self.domain, domain)
@mock.patch(DESIGNATE_UTILS + "DesignateScenario.clients")
def test_list_domains(self, mock_clients):
def test_list_domains(self):
scenario = utils.DesignateScenario()
domains_list = []
mock_clients("designate").domains.list.return_value = domains_list
return_domains_list = scenario._list_domains()
self.assertEqual(domains_list, return_domains_list)
self.assertEqual(self.clients("designate").domains.list.return_value,
return_domains_list)
self._test_atomic_action_timer(scenario.atomic_actions(),
"designate.list_domains")
@mock.patch(DESIGNATE_UTILS + "DesignateScenario.clients")
def test_delete_domain(self, mock_clients):
def test_delete_domain(self):
scenario = utils.DesignateScenario()
domain = scenario._create_domain()
@ -77,8 +73,7 @@ class DesignateScenarioTestCase(test.TestCase):
"designate.delete_domain")
@mock.patch(DESIGNATE_UTILS + "DesignateScenario._generate_random_name")
@mock.patch(DESIGNATE_UTILS + "DesignateScenario.clients")
def test_create_record(self, mock_clients, mock_random_name):
def test_create_record(self, mock_random_name):
scenario = utils.DesignateScenario()
random_name = "foo"
@ -91,79 +86,78 @@ class DesignateScenarioTestCase(test.TestCase):
# Create with randoms (name and type)
scenario._create_record(domain)
mock_clients("designate").records.create.assert_called_once_with(
self.clients("designate").records.create.assert_called_once_with(
domain["id"],
{"name": random_record_name, "type": "A", "data": "10.0.0.1"})
self._test_atomic_action_timer(scenario.atomic_actions(),
"designate.create_record")
mock_clients("designate").records.create.reset_mock()
self.clients("designate").records.create.reset_mock()
# Specify name
record = {"name": "www.zone.name.", "type": "ASD"}
scenario._create_record(domain, record)
mock_clients("designate").records.create.assert_called_once_with(
self.clients("designate").records.create.assert_called_once_with(
domain["id"], record)
@mock.patch(DESIGNATE_UTILS + "DesignateScenario.clients")
def test_list_records(self, mock_clients):
def test_list_records(self):
scenario = utils.DesignateScenario()
records_list = []
mock_clients("designate").records.list.return_value = records_list
return_records_list = scenario._list_records("123")
self.assertEqual(records_list, return_records_list)
self.assertEqual(self.clients("designate").records.list.return_value,
return_records_list)
self._test_atomic_action_timer(scenario.atomic_actions(),
"designate.list_records")
@mock.patch(DESIGNATE_UTILS + "DesignateScenario.clients")
def test_delete_record(self, mock_clients):
def test_delete_record(self):
scenario = utils.DesignateScenario()
mock_clients("designate").domains.create.return_value = {
"id": "123", "name": "asd"}
domain = scenario._create_domain()
mock_clients("designate").records.create.return_value = {"id": "123"}
record = scenario._create_record(domain)
scenario._delete_record(domain["id"], record["id"])
domain_id = mock.Mock()
record_id = mock.Mock()
scenario._delete_record(domain_id, record_id)
self.clients("designate").records.delete.assert_called_once_with(
domain_id, record_id)
self._test_atomic_action_timer(scenario.atomic_actions(),
"designate.delete_record")
self.clients("designate").records.delete.reset_mock()
scenario._delete_record(domain_id, record_id, atomic_action=False)
self.clients("designate").records.delete.assert_called_once_with(
domain_id, record_id)
@mock.patch(DESIGNATE_UTILS + "DesignateScenario._generate_random_name")
@mock.patch(DESIGNATE_UTILS + "DesignateScenario.admin_clients")
def test_create_server(self, mock_clients, mock_random_name):
def test_create_server(self, mock_random_name):
scenario = utils.DesignateScenario()
random_name = "foo"
explicit_name = "bar.io."
mock_random_name.return_value = random_name
mock_clients("designate").servers.create.return_value = self.server
self.admin_clients(
"designate").servers.create.return_value = self.server
# Check that the defaults / randoms are used if nothing is specified
server = scenario._create_server()
mock_clients("designate").servers.create.assert_called_once_with(
self.admin_clients("designate").servers.create.assert_called_once_with(
{"name": "name.%s." % random_name})
self.assertEqual(self.server, server)
self._test_atomic_action_timer(scenario.atomic_actions(),
"designate.create_server")
mock_clients("designate").servers.create.reset_mock()
self.admin_clients("designate").servers.create.reset_mock()
# Check that when specifying server name defaults are not used...
data = {"name": explicit_name}
server = scenario._create_server(data)
mock_clients("designate").servers.create.assert_called_once_with(data)
self.admin_clients(
"designate").servers.create.assert_called_once_with(data)
self.assertEqual(self.server, server)
@mock.patch(DESIGNATE_UTILS + "DesignateScenario.admin_clients")
def test_delete_server(self, mock_clients):
def test_delete_server(self):
scenario = utils.DesignateScenario()
scenario._delete_server("foo_id")
mock_clients("designate").servers.delete.assert_called_once_with(
self.admin_clients("designate").servers.delete.assert_called_once_with(
"foo_id")
self._test_atomic_action_timer(scenario.atomic_actions(),
"designate.delete_server")

View File

@ -21,7 +21,7 @@ from tests.unit import test
UTILS = "rally.plugins.openstack.scenarios.ec2.utils."
class EC2ServersTestCase(test.TestCase):
class EC2ServersTestCase(test.ClientsTestCase):
@mock.patch("rally.benchmark.utils.wait_for",
return_value="running_server")
@ -36,8 +36,7 @@ class EC2ServersTestCase(test.TestCase):
scenario = servers.EC2Servers()
scenario._update_resource = "foo_update"
mock_instances = mock.Mock(instances=["foo_inst"])
scenario.clients = mock.Mock()
scenario.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")
mock_wait.assert_called_once_with("foo_inst", is_ready="foo_state",

View File

@ -38,7 +38,7 @@ class EC2UtilsTestCase(test.TestCase):
resource.update.assert_called_once_with()
class EC2ScenarioTestCase(test.TestCase):
class EC2ScenarioTestCase(test.ClientsTestCase):
def setUp(self):
super(EC2ScenarioTestCase, self).setUp()
@ -58,9 +58,8 @@ class EC2ScenarioTestCase(test.TestCase):
self.assertIsNotNone(action_duration)
self.assertIsInstance(action_duration, float)
@mock.patch(EC2_UTILS + ".EC2Scenario.clients")
def test__boot_server(self, mock_clients):
mock_clients("ec2").run_instances.return_value = self.reservation
def test__boot_server(self):
self.clients("ec2").run_instances.return_value = self.reservation
ec2_scenario = utils.EC2Scenario(context={})
return_server = ec2_scenario._boot_server("image", "flavor")
expected = mock.call(

View File

@ -79,17 +79,14 @@ class FuelClientTestCase(test.TestCase):
client.task)
class FuelScenarioTestCase(test.TestCase):
class FuelScenarioTestCase(test.ClientsTestCase):
@mock.patch(UTILS + "FuelScenario.admin_clients")
def test__list_environments(self, mock_clients):
mock_admin = mock.Mock()
mock_clients.return_value = mock_admin
mock_admin.environment.get_all.return_value = (
"foo_environments_list")
def test__list_environments(self):
scenario = utils.FuelScenario()
self.assertEqual("foo_environments_list",
scenario._list_environments())
mock_admin.environment.get_all.assert_called_once_with()
self.assertEqual(
self.admin_clients("fuel").environment.get_all.return_value,
scenario._list_environments())
self.admin_clients(
"fuel").environment.get_all.assert_called_once_with()
self._test_atomic_action_timer(scenario.atomic_actions(),
"fuel.list_environments")

View File

@ -15,10 +15,7 @@
import mock
from rally import objects
from rally import osclients
from rally.plugins.openstack.scenarios.glance import images
from rally.plugins.openstack.scenarios.nova import servers
from tests.unit import fakes
from tests.unit import test
@ -64,23 +61,12 @@ class GlanceImagesTestCase(test.TestCase):
@mock.patch(GLANCE_IMAGES + "._boot_servers")
@mock.patch(GLANCE_IMAGES + "._create_image")
@mock.patch("rally.benchmark.runner.osclients")
def test_create_image_and_boot_instances(self,
mock_osclients,
mock_create_image,
mock_boot_servers):
glance_scenario = images.GlanceImages()
nova_scenario = servers.NovaServers()
fc = fakes.FakeClients()
mock_osclients.Clients.return_value = fc
fake_glance = fakes.FakeGlanceClient()
fc.glance = lambda: fake_glance
fake_nova = fakes.FakeNovaClient()
fc.nova = lambda: fake_nova
user_endpoint = objects.Endpoint("url", "user", "password", "tenant")
nova_scenario._clients = osclients.Clients(user_endpoint)
fake_image = fakes.FakeImage()
fake_servers = [object() for i in range(5)]
fake_servers = [mock.Mock() for i in range(5)]
mock_create_image.return_value = fake_image
mock_boot_servers.return_value = fake_servers
kwargs = {"fakearg": "f"}

View File

@ -27,7 +27,7 @@ BM_UTILS = "rally.benchmark.utils"
GLANCE_UTILS = "rally.plugins.openstack.scenarios.glance.utils"
class GlanceScenarioTestCase(test.TestCase):
class GlanceScenarioTestCase(test.ClientsTestCase):
def setUp(self):
super(GlanceScenarioTestCase, self).setUp()
@ -53,20 +53,18 @@ class GlanceScenarioTestCase(test.TestCase):
butils.get_from_manager(),
image_manager.create("fails", "url", "cf", "df"))
@mock.patch(GLANCE_UTILS + ".GlanceScenario.clients")
def test_list_images(self, mock_clients):
images_list = []
mock_clients("glance").images.list.return_value = images_list
def test_list_images(self):
scenario = utils.GlanceScenario()
return_images_list = scenario._list_images()
self.assertEqual(images_list, return_images_list)
self.clients("glance").images.list.assert_called_once_with()
self.assertEqual(list(self.clients("glance").images.list.return_value),
return_images_list)
self._test_atomic_action_timer(scenario.atomic_actions(),
"glance.list_images")
@mock.patch(GLANCE_UTILS + ".GlanceScenario.clients")
def test_create_image(self, mock_clients):
def test_create_image(self):
image_location = tempfile.NamedTemporaryFile()
mock_clients("glance").images.create.return_value = self.image
self.clients("glance").images.create.return_value = self.image
scenario = utils.GlanceScenario()
return_image = scenario._create_image("container_format",
image_location.name,
@ -81,9 +79,8 @@ class GlanceScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(scenario.atomic_actions(),
"glance.create_image")
@mock.patch(GLANCE_UTILS + ".GlanceScenario.clients")
def test_create_image_with_location(self, mock_clients):
mock_clients("glance").images.create.return_value = self.image
def test_create_image_with_location(self):
self.clients("glance").images.create.return_value = self.image
scenario = utils.GlanceScenario()
return_image = scenario._create_image("container_format",
"image_location",

View File

@ -21,7 +21,7 @@ from tests.unit import test
HEAT_STACKS = "rally.plugins.openstack.scenarios.heat.stacks.HeatStacks"
class HeatStacksTestCase(test.TestCase):
class HeatStacksTestCase(test.ClientsTestCase):
def setUp(self):
super(HeatStacksTestCase, self).setUp()
@ -49,25 +49,23 @@ class HeatStacksTestCase(test.TestCase):
self.default_environment)
mock_list.assert_called_once_with()
@mock.patch(HEAT_STACKS + ".clients")
@mock.patch(HEAT_STACKS + "._list_stacks")
def test_list_stack_and_resources(self, mock_list_stack, mock_clients):
def test_list_stack_and_resources(self, mock_list_stack):
stack = mock.Mock()
mock_list_stack.return_value = [stack]
heat_scenario = stacks.HeatStacks()
heat_scenario.list_stacks_and_resources()
mock_clients("heat").resources.list.assert_called_once_with(stack.id)
self.clients("heat").resources.list.assert_called_once_with(stack.id)
self._test_atomic_action_timer(
heat_scenario.atomic_actions(), "heat.list_resources_of_1_stacks")
@mock.patch(HEAT_STACKS + ".clients")
@mock.patch(HEAT_STACKS + "._list_stacks")
def test_list_stack_and_events(self, mock_list_stack, mock_clients):
def test_list_stack_and_events(self, mock_list_stack):
stack = mock.Mock()
mock_list_stack.return_value = [stack]
heat_scenario = stacks.HeatStacks()
heat_scenario.list_stacks_and_events()
mock_clients("heat").events.list.assert_called_once_with(stack.id)
self.clients("heat").events.list.assert_called_once_with(stack.id)
self._test_atomic_action_timer(
heat_scenario.atomic_actions(), "heat.list_events_of_1_stacks")

View File

@ -26,7 +26,7 @@ HEAT_UTILS = "rally.plugins.openstack.scenarios.heat.utils"
CONF = utils.CONF
class HeatScenarioTestCase(test.TestCase):
class HeatScenarioTestCase(test.ClientsTestCase):
def setUp(self):
super(HeatScenarioTestCase, self).setUp()
self.stack = mock.Mock()
@ -47,28 +47,26 @@ class HeatScenarioTestCase(test.TestCase):
self.dummy_files = ["dummy_file.yaml"]
self.dummy_environment = {"dummy_env": "dummy_env_value"}
@mock.patch(HEAT_UTILS + ".HeatScenario.clients")
def test_list_stacks(self, mock_clients):
stacks_list = []
mock_clients("heat").stacks.list.return_value = stacks_list
def test_list_stacks(self):
scenario = utils.HeatScenario()
return_stacks_list = scenario._list_stacks()
self.assertEqual(stacks_list, return_stacks_list)
self.clients("heat").stacks.list.assert_called_once_with()
self.assertEqual(list(self.clients("heat").stacks.list.return_value),
return_stacks_list)
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.list_stacks")
@mock.patch(HEAT_UTILS + ".HeatScenario.clients")
def test_create_stack(self, mock_clients):
mock_clients("heat").stacks.create.return_value = {
def test_create_stack(self):
self.clients("heat").stacks.create.return_value = {
"stack": {"id": "test_id"}
}
mock_clients("heat").stacks.get.return_value = self.stack
self.clients("heat").stacks.get.return_value = self.stack
scenario = utils.HeatScenario()
return_stack = scenario._create_stack(self.default_template,
self.dummy_parameters,
self.dummy_files,
self.dummy_environment)
args, kwargs = mock_clients("heat").stacks.create.call_args
args, kwargs = self.clients("heat").stacks.create.call_args
self.assertIn(self.dummy_parameters, kwargs.values())
self.assertIn(self.default_template, kwargs.values())
self.assertIn(self.dummy_files, kwargs.values())
@ -84,14 +82,13 @@ class HeatScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.create_stack")
@mock.patch(HEAT_UTILS + ".HeatScenario.clients")
def test_update_stack(self, mock_clients):
mock_clients("heat").stacks.update.return_value = None
def test_update_stack(self):
self.clients("heat").stacks.update.return_value = None
scenario = utils.HeatScenario()
scenario._update_stack(self.stack, self.default_template,
self.dummy_parameters, self.dummy_files,
self.dummy_environment)
args, kwargs = mock_clients("heat").stacks.update.call_args
args, kwargs = self.clients("heat").stacks.update.call_args
self.assertIn(self.dummy_parameters, kwargs.values())
self.assertIn(self.default_template, kwargs.values())
self.assertIn(self.dummy_files, kwargs.values())
@ -107,11 +104,10 @@ class HeatScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.update_stack")
@mock.patch(HEAT_UTILS + ".HeatScenario.clients")
def test_check_stack(self, mock_clients):
def test_check_stack(self):
scenario = utils.HeatScenario()
scenario._check_stack(self.stack)
mock_clients("heat").actions.check.assert_called_once_with(
self.clients("heat").actions.check.assert_called_once_with(
self.stack.id)
self.wait_for.mock.assert_called_once_with(
self.stack,
@ -135,11 +131,10 @@ class HeatScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.delete_stack")
@mock.patch(HEAT_UTILS + ".HeatScenario.clients")
def test_suspend_stack(self, mock_clients):
def test_suspend_stack(self):
scenario = utils.HeatScenario()
scenario._suspend_stack(self.stack)
mock_clients("heat").actions.suspend.assert_called_once_with(
self.clients("heat").actions.suspend.assert_called_once_with(
self.stack.id)
self.wait_for.mock.assert_called_once_with(
self.stack,
@ -151,11 +146,10 @@ class HeatScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(scenario.atomic_actions(),
"heat.suspend_stack")
@mock.patch(HEAT_UTILS + ".HeatScenario.clients")
def test_resume_stack(self, mock_clients):
def test_resume_stack(self):
scenario = utils.HeatScenario()
scenario._resume_stack(self.stack)
mock_clients("heat").actions.resume.assert_called_once_with(
self.clients("heat").actions.resume.assert_called_once_with(
self.stack.id)
self.wait_for.mock.assert_called_once_with(
self.stack,
@ -168,17 +162,16 @@ class HeatScenarioTestCase(test.TestCase):
"heat.resume_stack")
class HeatScenarioNegativeTestCase(test.TestCase):
@mock.patch(HEAT_UTILS + ".HeatScenario.clients")
def test_failed_create_stack(self, mock_clients):
mock_clients("heat").stacks.create.return_value = {
class HeatScenarioNegativeTestCase(test.ClientsTestCase):
def test_failed_create_stack(self):
self.clients("heat").stacks.create.return_value = {
"stack": {"id": "test_id"}
}
stack = mock.Mock()
resource = mock.Mock()
resource.stack_status = "CREATE_FAILED"
stack.manager.get.return_value = resource
mock_clients("heat").stacks.get.return_value = stack
self.clients("heat").stacks.get.return_value = stack
scenario = utils.HeatScenario()
try:
ex = self.assertRaises(exceptions.GetResourceErrorStatus,
@ -187,13 +180,12 @@ class HeatScenarioNegativeTestCase(test.TestCase):
except exceptions.TimeoutException:
raise self.fail("Unrecognized error status")
@mock.patch(HEAT_UTILS + ".HeatScenario.clients")
def test_failed_update_stack(self, mock_clients):
def test_failed_update_stack(self):
stack = mock.Mock()
resource = mock.Mock()
resource.stack_status = "UPDATE_FAILED"
stack.manager.get.return_value = resource
mock_clients("heat").stacks.get.return_value = stack
self.clients("heat").stacks.get.return_value = stack
scenario = utils.HeatScenario()
try:
ex = self.assertRaises(exceptions.GetResourceErrorStatus,

View File

@ -45,23 +45,18 @@ class KeystoneUtilsTestCase(test.TestCase):
self.assertEqual(utils.is_temporary(resource), is_valid)
class KeystoneScenarioTestCase(test.TestCase):
class KeystoneScenarioTestCase(test.ClientsTestCase):
@mock.patch(UTILS + "uuid.uuid4", return_value="pwd")
@mock.patch(UTILS + "KeystoneScenario._generate_random_name",
return_value="abc")
def test_user_create(self, mock_gen_name, mock_uuid4):
user = {}
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.users.create = mock.MagicMock(return_value=user)
fake_clients = fakes.FakeClients()
fake_clients._keystone = fake_keystone
scenario = utils.KeystoneScenario(admin_clients=fake_clients)
scenario = utils.KeystoneScenario()
result = scenario._user_create()
self.assertEqual(user, result)
fake_keystone.users.create.assert_called_once_with(
self.assertEqual(
self.admin_clients("keystone").users.create.return_value, result)
self.admin_clients("keystone").users.create.assert_called_once_with(
mock_gen_name.return_value,
password=mock_uuid4.return_value,
email=mock_gen_name.return_value + "@rally.me")
@ -71,36 +66,26 @@ class KeystoneScenarioTestCase(test.TestCase):
@mock.patch(UTILS + "KeystoneScenario._generate_random_name")
def test_role_create(self, mock_gen_name):
name = "abc"
mock_gen_name.return_value = name
role = {}
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.roles.create = mock.MagicMock(return_value=role)
fake_clients = fakes.FakeClients()
fake_clients._keystone = fake_keystone
scenario = utils.KeystoneScenario(admin_clients=fake_clients)
scenario = utils.KeystoneScenario()
result = scenario._role_create()
self.assertEqual(role, result)
fake_keystone.roles.create.assert_called_once_with(name)
self.assertEqual(
self.admin_clients("keystone").roles.create.return_value, result)
self.admin_clients("keystone").roles.create.assert_called_once_with(
mock_gen_name.return_value)
self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.create_role")
def test_list_roles_for_user(self):
user = mock.MagicMock()
tenant = mock.MagicMock()
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.roles.roles_for_user = mock.MagicMock()
fake_clients = fakes.FakeClients()
fake_clients._keystone = fake_keystone
scenario = utils.KeystoneScenario(admin_clients=fake_clients)
scenario = utils.KeystoneScenario()
scenario._list_roles_for_user(user, tenant)
fake_keystone.roles.roles_for_user.assert_called_once_with(user,
tenant)
self.admin_clients(
"keystone").roles.roles_for_user.assert_called_once_with(user,
tenant)
self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.list_roles")
@ -108,17 +93,14 @@ class KeystoneScenarioTestCase(test.TestCase):
user = mock.MagicMock()
role = mock.MagicMock()
tenant = mock.MagicMock()
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.roles.add_user_role = mock.MagicMock()
fake_clients = fakes.FakeClients()
fake_clients._keystone = fake_keystone
scenario = utils.KeystoneScenario(admin_clients=fake_clients)
scenario = utils.KeystoneScenario()
scenario._role_add(user=user.id, role=role.id, tenant=tenant.id)
fake_keystone.roles.add_user_role.assert_called_once_with(user.id,
role.id,
tenant.id)
self.admin_clients(
"keystone").roles.add_user_role.assert_called_once_with(user.id,
role.id,
tenant.id)
self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.add_role")
@ -136,61 +118,45 @@ class KeystoneScenarioTestCase(test.TestCase):
user = mock.MagicMock()
role = mock.MagicMock()
tenant = mock.MagicMock()
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.roles.remove_user_role = mock.MagicMock()
fake_clients = fakes.FakeClients()
fake_clients._keystone = fake_keystone
scenario = utils.KeystoneScenario(admin_clients=fake_clients)
scenario = utils.KeystoneScenario()
scenario._role_remove(user=user, role=role, tenant=tenant)
fake_keystone.roles.remove_user_role.assert_called_once_with(user,
role,
tenant)
self.admin_clients(
"keystone").roles.remove_user_role.assert_called_once_with(user,
role,
tenant)
self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.remove_role")
@mock.patch(UTILS + "KeystoneScenario._generate_random_name")
def test_tenant_create(self, mock_gen_name):
name = "abc"
mock_gen_name.return_value = name
tenant = {}
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.tenants.create = mock.MagicMock(return_value=tenant)
fake_clients = fakes.FakeClients()
fake_clients._keystone = fake_keystone
scenario = utils.KeystoneScenario(admin_clients=fake_clients)
scenario = utils.KeystoneScenario()
result = scenario._tenant_create()
self.assertEqual(tenant, result)
fake_keystone.tenants.create.assert_called_once_with(name)
self.assertEqual(
self.admin_clients("keystone").tenants.create.return_value, result)
self.admin_clients("keystone").tenants.create.assert_called_once_with(
mock_gen_name.return_value)
self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.create_tenant")
@mock.patch(UTILS + "KeystoneScenario._generate_random_name")
def test_service_create(self, mock_gen_name):
def test_service_create(self):
name = "abc"
mock_gen_name.return_value = name
service_type = name + "service_type"
description = name + "_description"
service = {}
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.services.create = mock.MagicMock(return_value=service)
fake_clients = fakes.FakeClients()
fake_clients._keystone = fake_keystone
scenario = utils.KeystoneScenario(admin_clients=fake_clients)
scenario = utils.KeystoneScenario()
result = scenario._service_create(name=name,
service_type=service_type,
description=description)
self.assertEqual(service, result)
fake_keystone.services.create.assert_called_once_with(name,
service_type,
description)
self.assertEqual(
self.admin_clients("keystone").services.create.return_value,
result)
self.admin_clients("keystone").services.create.assert_called_once_with(
name, service_type, description)
self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.create_service")
@ -200,122 +166,85 @@ class KeystoneScenarioTestCase(test.TestCase):
mock_gen_name.return_value = name
tenant = mock.MagicMock()
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.users.create = mock.MagicMock()
fake_clients = fakes.FakeClients()
fake_clients._keystone = fake_keystone
scenario = utils.KeystoneScenario(admin_clients=fake_clients)
scenario = utils.KeystoneScenario()
scenario._users_create(tenant, users_per_tenant=1, name_length=10)
fake_keystone.users.create.assert_called_once_with(
self.admin_clients("keystone").users.create.assert_called_once_with(
name, password=name, email=name + "@rally.me",
tenant_id=tenant.id)
self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.create_users")
def test_list_users(self):
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.users.list = mock.MagicMock()
fake_clients = fakes.FakeClients()
fake_clients._keystone = fake_keystone
scenario = utils.KeystoneScenario(admin_clients=fake_clients)
scenario = utils.KeystoneScenario()
scenario._list_users()
fake_keystone.users.list.assert_called_once_with()
self.admin_clients("keystone").users.list.assert_called_once_with()
self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.list_users")
def test_list_tenants(self):
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.tenants.list = mock.MagicMock()
fake_clients = fakes.FakeClients()
fake_clients._keystone = fake_keystone
scenario = utils.KeystoneScenario(admin_clients=fake_clients)
scenario = utils.KeystoneScenario()
scenario._list_tenants()
fake_keystone.tenants.list.assert_called_once_with()
self.admin_clients("keystone").tenants.list.assert_called_once_with()
self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.list_tenants")
def test_list_services(self):
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.services.list = mock.MagicMock()
fake_clients = fakes.FakeClients()
fake_clients._keystone = fake_keystone
scenario = utils.KeystoneScenario(admin_clients=fake_clients)
scenario = utils.KeystoneScenario()
scenario._list_services()
fake_keystone.services.list.assert_called_once_with()
self.admin_clients("keystone").services.list.assert_called_once_with()
self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.service_list")
def test_delete_service(self):
service = mock.MagicMock()
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.services.delete = mock.MagicMock()
fake_clients = fakes.FakeClients()
fake_clients._keystone = fake_keystone
scenario = utils.KeystoneScenario(admin_clients=fake_clients)
scenario = utils.KeystoneScenario()
scenario._delete_service(service_id=service.id)
fake_keystone.services.delete.assert_called_once_with(service.id)
self.admin_clients("keystone").services.delete.assert_called_once_with(
service.id)
self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.delete_service")
def test_get_tenant(self):
tenant = mock.MagicMock()
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.tenants.get = mock.MagicMock(return_value=tenant)
fake_clients = fakes.FakeClients()
fake_clients._keystone = fake_keystone
scenario = utils.KeystoneScenario(admin_clients=fake_clients)
scenario = utils.KeystoneScenario()
scenario._get_tenant(tenant_id=tenant.id)
fake_keystone.tenants.get.assert_called_once_with(tenant.id)
self.admin_clients("keystone").tenants.get.assert_called_once_with(
tenant.id)
self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.get_tenant")
def test_get_user(self):
user = mock.MagicMock()
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.users.get = mock.MagicMock(return_value=user)
fake_clients = fakes.FakeClients()
fake_clients._keystone = fake_keystone
scenario = utils.KeystoneScenario(admin_clients=fake_clients)
scenario = utils.KeystoneScenario()
scenario._get_user(user_id=user.id)
fake_keystone.users.get.assert_called_once_with(user.id)
self.admin_clients("keystone").users.get.assert_called_once_with(
user.id)
self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.get_user")
def test_get_role(self):
role = mock.MagicMock()
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.roles.get = mock.MagicMock(return_value=role)
fake_clients = fakes.FakeClients()
fake_clients._keystone = fake_keystone
scenario = utils.KeystoneScenario(admin_clients=fake_clients)
scenario = utils.KeystoneScenario()
scenario._get_role(role_id=role.id)
fake_keystone.roles.get.assert_called_once_with(role.id)
self.admin_clients("keystone").roles.get.assert_called_once_with(
role.id)
self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.get_role")
def test_get_service(self):
service = mock.MagicMock()
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.services.get = mock.MagicMock(return_value=service)
fake_clients = fakes.FakeClients()
fake_clients._keystone = fake_keystone
scenario = utils.KeystoneScenario(admin_clients=fake_clients)
scenario = utils.KeystoneScenario()
scenario._get_service(service_id=service.id)
fake_keystone.services.get.assert_called_once_with(service.id)
self.admin_clients("keystone").services.get.assert_called_once_with(
service.id)
self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.get_service")
@ -323,33 +252,25 @@ class KeystoneScenarioTestCase(test.TestCase):
tenant = mock.MagicMock()
description = tenant.name + "_description_updated_test"
name = tenant.name + "test_updated_test"
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.tenants.update = mock.MagicMock()
fake_clients = fakes.FakeClients()
fake_clients._keystone = fake_keystone
scenario = utils.KeystoneScenario(admin_clients=fake_clients)
scenario = utils.KeystoneScenario()
scenario._update_tenant(tenant=tenant, name=name,
description=description)
fake_keystone.tenants.update.assert_called_once_with(tenant.id, name,
description)
self.admin_clients("keystone").tenants.update.assert_called_once_with(
tenant.id, name, description)
self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.update_tenant")
def test_update_user_password(self):
password = "pswd"
user = mock.MagicMock()
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.users.update_password = mock.MagicMock()
fake_clients = fakes.FakeClients()
fake_clients._keystone = fake_keystone
scenario = utils.KeystoneScenario(admin_clients=fake_clients)
scenario = utils.KeystoneScenario()
scenario._update_user_password(password=password, user_id=user.id)
fake_keystone.users.update_password.assert_called_once_with(user.id,
password)
self.admin_clients(
"keystone").users.update_password.assert_called_once_with(user.id,
password)
self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.update_user_password")

View File

@ -13,50 +13,35 @@
# License for the specific language governing permissions and limitations
# under the License.
import mock
from rally.plugins.openstack.scenarios.mistral import utils
from tests.unit import test
MISTRAL_UTILS = "rally.plugins.openstack.scenarios.mistral.utils"
class MistralScenarioTestCase(test.TestCase):
class MistralScenarioTestCase(test.ClientsTestCase):
def _test_atomic_action_timer(self, atomic_actions, name):
action_duration = atomic_actions.get(name)
self.assertIsNotNone(action_duration)
self.assertIsInstance(action_duration, float)
@mock.patch(MISTRAL_UTILS + ".MistralScenario.clients")
def test_list_workbooks(self, mock_clients):
wbs_list = []
mock_clients("mistral").workbooks.list.return_value = wbs_list
def test_list_workbooks(self):
scenario = utils.MistralScenario()
return_wbs_list = scenario._list_workbooks()
self.assertEqual(wbs_list, return_wbs_list)
self.assertEqual(
self.clients("mistral").workbooks.list.return_value,
return_wbs_list)
self._test_atomic_action_timer(scenario.atomic_actions(),
"mistral.list_workbooks")
@mock.patch(MISTRAL_UTILS + ".MistralScenario.clients")
def test_create_workbook(self, mock_clients):
def test_create_workbook(self):
definition = "version: \"2.0\"\nname: wb"
mock_clients("mistral").workbooks.create.return_value = "wb"
scenario = utils.MistralScenario()
wb = scenario._create_workbook(definition)
self.assertEqual("wb", wb)
self.assertEqual(scenario._create_workbook(definition),
self.clients("mistral").workbooks.create.return_value)
self._test_atomic_action_timer(scenario.atomic_actions(),
"mistral.create_workbook")
@mock.patch(MISTRAL_UTILS + ".MistralScenario.clients")
def test_delete_workbook(self, mock_clients):
wb = mock.Mock()
wb.name = "wb"
mock_clients("mistral").workbooks.delete.return_value = "ok"
def test_delete_workbook(self):
scenario = utils.MistralScenario()
scenario._delete_workbook(wb.name)
mock_clients("mistral").workbooks.delete.assert_called_once_with(
wb.name
)
scenario._delete_workbook("wb_name")
self.clients("mistral").workbooks.delete.assert_called_once_with(
"wb_name")
self._test_atomic_action_timer(scenario.atomic_actions(),
"mistral.delete_workbook")

View File

@ -23,7 +23,7 @@ BM_UTILS = "rally.benchmark.utils"
MRN_UTILS = "rally.plugins.openstack.scenarios.murano.utils"
class MuranoScenarioTestCase(test.TestCase):
class MuranoScenarioTestCase(test.ClientsTestCase):
def setUp(self):
super(MuranoScenarioTestCase, self).setUp()
@ -39,20 +39,17 @@ class MuranoScenarioTestCase(test.TestCase):
self.gfm = self.get_fm.mock
self.useFixture(mockpatch.Patch("time.sleep"))
@mock.patch(MRN_UTILS + ".MuranoScenario.clients")
def test_list_environments(self, mock_clients):
mock_clients("murano").environments.list.return_value = []
def test_list_environments(self):
self.clients("murano").environments.list.return_value = []
scenario = utils.MuranoScenario()
return_environments_list = scenario._list_environments()
self.assertEqual([], return_environments_list)
self._test_atomic_action_timer(scenario.atomic_actions(),
"murano.list_environments")
@mock.patch(MRN_UTILS + ".MuranoScenario.clients")
def test_create_environments(self, mock_clients):
def test_create_environments(self):
mock_create = mock.Mock(return_value="foo_env")
mock_clients("murano").environments.create = mock_create
self.clients("murano").environments.create = mock_create
scenario = utils.MuranoScenario()
create_env = scenario._create_environment("env_name")
self.assertEqual("foo_env", create_env)
@ -60,13 +57,12 @@ class MuranoScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(scenario.atomic_actions(),
"murano.create_environment")
@mock.patch(MRN_UTILS + ".MuranoScenario.clients")
def test_delete_environment(self, mock_clients):
def test_delete_environment(self):
environment = mock.Mock(id="id")
mock_clients("murano").environments.delete.return_value = "ok"
self.clients("murano").environments.delete.return_value = "ok"
scenario = utils.MuranoScenario()
scenario._delete_environment(environment)
mock_clients("murano").environments.delete.assert_called_once_with(
self.clients("murano").environments.delete.assert_called_once_with(
environment.id
)
@ -78,18 +74,16 @@ class MuranoScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(scenario.atomic_actions(),
"murano.delete_environment")
@mock.patch(MRN_UTILS + ".MuranoScenario.clients")
def test_create_session(self, mock_clients):
mock_clients("murano").sessions.configure.return_value = "sess"
def test_create_session(self):
self.clients("murano").sessions.configure.return_value = "sess"
scenario = utils.MuranoScenario()
create_sess = scenario._create_session("id")
self.assertEqual("sess", create_sess)
self._test_atomic_action_timer(scenario.atomic_actions(),
"murano.create_session")
@mock.patch(MRN_UTILS + ".MuranoScenario.clients")
def test__create_service(self, mock_clients,):
mock_clients("murano").services.post.return_value = "app"
def test__create_service(self,):
self.clients("murano").services.post.return_value = "app"
mock_env = mock.Mock(id="ip")
mock_sess = mock.Mock(id="ip")
scenario = utils.MuranoScenario()
@ -102,15 +96,14 @@ class MuranoScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(scenario.atomic_actions(),
"murano.create_service")
@mock.patch(MRN_UTILS + ".MuranoScenario.clients")
def test_deploy_environment(self, mock_clients):
def test_deploy_environment(self):
environment = mock.Mock(id="id")
session = mock.Mock(id="id")
mock_clients("murano").sessions.deploy.return_value = "ok"
self.clients("murano").sessions.deploy.return_value = "ok"
scenario = utils.MuranoScenario()
scenario._deploy_environment(environment, session)
mock_clients("murano").sessions.deploy.assert_called_once_with(
self.clients("murano").sessions.deploy.assert_called_once_with(
environment.id, session.id
)

View File

@ -22,7 +22,7 @@ NEUTRON_NETWORKS = ("rally.plugins.openstack.scenarios.neutron.network"
".NeutronNetworks")
class NeutronNetworksTestCase(test.TestCase):
class NeutronNetworksTestCase(test.ClientsTestCase):
@mock.patch(NEUTRON_NETWORKS + "._list_networks")
@mock.patch(NEUTRON_NETWORKS + "._create_network")
@ -248,9 +248,7 @@ class NeutronNetworksTestCase(test.TestCase):
@mock.patch(NEUTRON_NETWORKS + "._list_routers")
@mock.patch(NEUTRON_NETWORKS + "._create_router")
@mock.patch(NEUTRON_NETWORKS + "._create_network_and_subnets")
@mock.patch(NEUTRON_NETWORKS + ".clients")
def test_create_and_list_routers(self,
mock_clients,
mock_create_network_and_subnets,
mock_create_router,
mock_list):
@ -271,7 +269,7 @@ class NeutronNetworksTestCase(test.TestCase):
}
}
mock_create_network_and_subnets.return_value = (net, [subnet])
mock_clients("neutron").add_interface_router = mock.Mock()
self.clients("neutron").add_interface_router = mock.Mock()
router = {
"router": {
"name": "router-name",
@ -290,7 +288,7 @@ class NeutronNetworksTestCase(test.TestCase):
mock_create_router.assert_has_calls(
[mock.call({})] * subnets_per_network)
mock_clients("neutron").add_interface_router.assert_has_calls(
self.clients("neutron").add_interface_router.assert_has_calls(
[mock.call(router["router"]["id"],
{"subnet_id": subnet["subnet"]["id"]})
] * subnets_per_network)
@ -298,7 +296,7 @@ class NeutronNetworksTestCase(test.TestCase):
mock_create_network_and_subnets.reset_mock()
mock_create_router.reset_mock()
mock_clients("neutron").add_interface_router.reset_mock()
self.clients("neutron").add_interface_router.reset_mock()
mock_list.reset_mock()
# Custom options
@ -317,7 +315,7 @@ class NeutronNetworksTestCase(test.TestCase):
mock_create_router.assert_has_calls(
[mock.call(router_create_args)] * subnets_per_network)
mock_clients("neutron").add_interface_router.assert_has_calls(
self.clients("neutron").add_interface_router.assert_has_calls(
[mock.call(router["router"]["id"],
{"subnet_id": subnet["subnet"]["id"]})
] * subnets_per_network)
@ -327,9 +325,7 @@ class NeutronNetworksTestCase(test.TestCase):
@mock.patch(NEUTRON_NETWORKS + "._update_router")
@mock.patch(NEUTRON_NETWORKS + "._create_router")
@mock.patch(NEUTRON_NETWORKS + "._create_network_and_subnets")
@mock.patch(NEUTRON_NETWORKS + ".clients")
def test_create_and_update_routers(self,
mock_clients,
mock_create_network_and_subnets,
mock_create_router,
mock_update_router):
@ -361,7 +357,7 @@ class NeutronNetworksTestCase(test.TestCase):
}
mock_create_router.return_value = router
mock_create_network_and_subnets.return_value = (net, [subnet])
mock_clients("neutron").add_interface_router = mock.Mock()
self.clients("neutron").add_interface_router = mock.Mock()
# Default options
scenario.create_and_update_routers(
@ -374,7 +370,7 @@ class NeutronNetworksTestCase(test.TestCase):
mock_create_router.assert_has_calls(
[mock.call({})] * subnets_per_network)
mock_clients("neutron").add_interface_router.assert_has_calls(
self.clients("neutron").add_interface_router.assert_has_calls(
[mock.call(router["router"]["id"],
{"subnet_id": subnet["subnet"]["id"]})
] * subnets_per_network)
@ -385,7 +381,7 @@ class NeutronNetworksTestCase(test.TestCase):
mock_create_network_and_subnets.reset_mock()
mock_create_router.reset_mock()
mock_clients("neutron").add_interface_router.reset_mock()
self.clients("neutron").add_interface_router.reset_mock()
mock_update_router.reset_mock()
# Custom options
@ -405,7 +401,7 @@ class NeutronNetworksTestCase(test.TestCase):
mock_create_router.assert_has_calls(
[mock.call(router_create_args)] * subnets_per_network)
mock_clients("neutron").add_interface_router.assert_has_calls(
self.clients("neutron").add_interface_router.assert_has_calls(
[mock.call(router["router"]["id"],
{"subnet_id": subnet["subnet"]["id"]})
] * subnets_per_network)
@ -417,9 +413,7 @@ class NeutronNetworksTestCase(test.TestCase):
@mock.patch(NEUTRON_NETWORKS + "._delete_router")
@mock.patch(NEUTRON_NETWORKS + "._create_router")
@mock.patch(NEUTRON_NETWORKS + "._create_network_and_subnets")
@mock.patch(NEUTRON_NETWORKS + ".clients")
def test_create_and_delete_routers(self,
mock_clients,
mock_create_network_and_subnets,
mock_create_router,
mock_delete_router):
@ -448,7 +442,7 @@ class NeutronNetworksTestCase(test.TestCase):
mock_create_router.return_value = router
mock_create_network_and_subnets.return_value = (net, [subnet])
mock_clients("neutron").add_interface_router = mock.Mock()
self.clients("neutron").add_interface_router = mock.Mock()
# Default options
scenario.create_and_delete_routers(
@ -460,7 +454,7 @@ class NeutronNetworksTestCase(test.TestCase):
mock_create_router.assert_has_calls(
[mock.call({})] * subnets_per_network)
mock_clients("neutron").add_interface_router.assert_has_calls(
self.clients("neutron").add_interface_router.assert_has_calls(
[mock.call(router["router"]["id"],
{"subnet_id": subnet["subnet"]["id"]})
] * subnets_per_network)
@ -470,7 +464,7 @@ class NeutronNetworksTestCase(test.TestCase):
mock_create_network_and_subnets.reset_mock()
mock_create_router.reset_mock()
mock_clients("neutron").add_interface_router.reset_mock()
self.clients("neutron").add_interface_router.reset_mock()
mock_delete_router.reset_mock()
# Custom options
@ -489,7 +483,7 @@ class NeutronNetworksTestCase(test.TestCase):
mock_create_router.assert_has_calls(
[mock.call(router_create_args)] * subnets_per_network)
mock_clients("neutron").add_interface_router.assert_has_calls(
self.clients("neutron").add_interface_router.assert_has_calls(
[mock.call(router["router"]["id"],
{"subnet_id": subnet["subnet"]["id"]})
] * subnets_per_network)

View File

@ -16,60 +16,56 @@
import mock
from rally.plugins.openstack.scenarios.neutron import utils
from tests.unit import fakes
from tests.unit import test
NEUTRON_UTILS = "rally.plugins.openstack.scenarios.neutron.utils."
class NeutronScenarioTestCase(test.TestCase):
class NeutronScenarioTestCase(test.ClientsTestCase):
def setUp(self):
super(NeutronScenarioTestCase, self).setUp()
self.network = mock.Mock()
@mock.patch(NEUTRON_UTILS + "NeutronScenario._generate_random_name")
@mock.patch(NEUTRON_UTILS + "NeutronScenario.clients")
def test_create_network(self, mock_clients, mock_random_name):
def test_create_network(self, mock_random_name):
neutron_scenario = utils.NeutronScenario()
explicit_name = "explicit_name"
random_name = "random_name"
mock_random_name.return_value = random_name
mock_clients("neutron").create_network.return_value = self.network
self.clients("neutron").create_network.return_value = self.network
# Network name is specified
network_data = {"name": explicit_name, "admin_state_up": False}
expected_network_data = {"network": network_data}
network = neutron_scenario._create_network(network_data)
mock_clients("neutron").create_network.assert_called_once_with(
self.clients("neutron").create_network.assert_called_once_with(
expected_network_data)
self.assertEqual(self.network, network)
self._test_atomic_action_timer(neutron_scenario.atomic_actions(),
"neutron.create_network")
mock_clients("neutron").create_network.reset_mock()
self.clients("neutron").create_network.reset_mock()
# Network name is random generated
network_data = {"admin_state_up": False}
expected_network_data["network"]["name"] = random_name
network = neutron_scenario._create_network(network_data)
mock_clients("neutron").create_network.assert_called_once_with(
self.clients("neutron").create_network.assert_called_once_with(
expected_network_data)
@mock.patch(NEUTRON_UTILS + "NeutronScenario.clients")
def test_list_networks(self, mock_clients):
def test_list_networks(self):
scenario = utils.NeutronScenario()
networks_list = []
networks_dict = {"networks": networks_list}
mock_clients("neutron").list_networks.return_value = networks_dict
self.clients("neutron").list_networks.return_value = networks_dict
return_networks_list = scenario._list_networks()
self.assertEqual(networks_list, return_networks_list)
self._test_atomic_action_timer(scenario.atomic_actions(),
"neutron.list_networks")
@mock.patch(NEUTRON_UTILS + "NeutronScenario.clients")
def test_update_network(self, mock_clients):
def test_update_network(self):
scenario = utils.NeutronScenario()
expected_network = {
"network": {
@ -77,20 +73,19 @@ class NeutronScenarioTestCase(test.TestCase):
"admin_state_up": False
}
}
mock_clients("neutron").update_network.return_value = expected_network
self.clients("neutron").update_network.return_value = expected_network
network = {"network": {"name": "network-name", "id": "network-id"}}
network_update_args = {"name": "_updated", "admin_state_up": False}
result_network = scenario._update_network(network, network_update_args)
mock_clients("neutron").update_network.assert_called_once_with(
self.clients("neutron").update_network.assert_called_once_with(
network["network"]["id"], expected_network)
self.assertEqual(result_network, expected_network)
self._test_atomic_action_timer(scenario.atomic_actions(),
"neutron.update_network")
@mock.patch(NEUTRON_UTILS + "NeutronScenario.clients")
def test_delete_network(self, mock_clients):
def test_delete_network(self):
scenario = utils.NeutronScenario()
network_create_args = {}
@ -101,8 +96,7 @@ class NeutronScenarioTestCase(test.TestCase):
@mock.patch(NEUTRON_UTILS + "NeutronScenario._generate_random_name",
return_value="test_subnet")
@mock.patch(NEUTRON_UTILS + "NeutronScenario.clients")
def test_create_subnet(self, mock_clients, mock_random_name):
def test_create_subnet(self, mock_random_name):
scenario = utils.NeutronScenario()
network_id = "fake-id"
start_cidr = "192.168.0.0/24"
@ -120,25 +114,24 @@ class NeutronScenarioTestCase(test.TestCase):
# Default options
subnet_data = {"network_id": network_id}
scenario._create_subnet(network, subnet_data, start_cidr)
mock_clients("neutron").create_subnet.assert_called_once_with(
self.clients("neutron").create_subnet.assert_called_once_with(
expected_subnet_data)
self._test_atomic_action_timer(scenario.atomic_actions(),
"neutron.create_subnet")
mock_clients("neutron").create_subnet.reset_mock()
self.clients("neutron").create_subnet.reset_mock()
# Custom options
extras = {"cidr": "192.168.16.0/24", "allocation_pools": []}
subnet_data.update(extras)
expected_subnet_data["subnet"].update(extras)
scenario._create_subnet(network, subnet_data)
mock_clients("neutron").create_subnet.assert_called_once_with(
self.clients("neutron").create_subnet.assert_called_once_with(
expected_subnet_data)
@mock.patch(NEUTRON_UTILS + "NeutronScenario.clients")
def test_list_subnets(self, mock_clients):
def test_list_subnets(self):
subnets = [{"name": "fake1"}, {"name": "fake2"}]
mock_clients("neutron").list_subnets.return_value = {
self.clients("neutron").list_subnets.return_value = {
"subnets": subnets
}
scenario = utils.NeutronScenario()
@ -147,8 +140,7 @@ class NeutronScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(scenario.atomic_actions(),
"neutron.list_subnets")
@mock.patch(NEUTRON_UTILS + "NeutronScenario.clients")
def test_update_subnet(self, mock_clients):
def test_update_subnet(self):
scenario = utils.NeutronScenario()
expected_subnet = {
"subnet": {
@ -156,20 +148,19 @@ class NeutronScenarioTestCase(test.TestCase):
"enable_dhcp": False
}
}
mock_clients("neutron").update_subnet.return_value = expected_subnet
self.clients("neutron").update_subnet.return_value = expected_subnet
subnet = {"subnet": {"name": "subnet-name", "id": "subnet-id"}}
subnet_update_args = {"name": "_updated", "enable_dhcp": False}
result_subnet = scenario._update_subnet(subnet, subnet_update_args)
mock_clients("neutron").update_subnet.assert_called_once_with(
self.clients("neutron").update_subnet.assert_called_once_with(
subnet["subnet"]["id"], expected_subnet)
self.assertEqual(result_subnet, expected_subnet)
self._test_atomic_action_timer(scenario.atomic_actions(),
"neutron.update_subnet")
@mock.patch(NEUTRON_UTILS + "NeutronScenario.clients")
def test_delete_subnet(self, mock_clients):
def test_delete_subnet(self):
scenario = utils.NeutronScenario()
network = scenario._create_network({})
@ -180,43 +171,40 @@ class NeutronScenarioTestCase(test.TestCase):
"neutron.delete_subnet")
@mock.patch(NEUTRON_UTILS + "NeutronScenario._generate_random_name")
@mock.patch(NEUTRON_UTILS + "NeutronScenario.clients")
def test_create_router(self, mock_clients, mock_random_name):
def test_create_router(self, mock_random_name):
scenario = utils.NeutronScenario()
router = mock.Mock()
explicit_name = "explicit_name"
random_name = "random_name"
mock_random_name.return_value = random_name
mock_clients("neutron").create_router.return_value = router
self.clients("neutron").create_router.return_value = router
# Default options
result_router = scenario._create_router({})
mock_clients("neutron").create_router.assert_called_once_with(
self.clients("neutron").create_router.assert_called_once_with(
{"router": {"name": random_name}})
self.assertEqual(result_router, router)
self._test_atomic_action_timer(scenario.atomic_actions(),
"neutron.create_router")
mock_clients("neutron").create_router.reset_mock()
self.clients("neutron").create_router.reset_mock()
# Custom options
router_data = {"name": explicit_name, "admin_state_up": True}
result_router = scenario._create_router(router_data)
mock_clients("neutron").create_router.assert_called_once_with(
self.clients("neutron").create_router.assert_called_once_with(
{"router": router_data})
@mock.patch(NEUTRON_UTILS + "NeutronScenario.clients")
def test_list_routers(self, mock_clients):
def test_list_routers(self):
scenario = utils.NeutronScenario()
routers = [mock.Mock()]
mock_clients("neutron").list_routers.return_value = {
self.clients("neutron").list_routers.return_value = {
"routers": routers}
self.assertEqual(routers, scenario._list_routers())
self._test_atomic_action_timer(scenario.atomic_actions(),
"neutron.list_routers")
@mock.patch(NEUTRON_UTILS + "NeutronScenario.clients")
def test_update_router(self, mock_clients):
def test_update_router(self):
scenario = utils.NeutronScenario()
expected_router = {
"router": {
@ -224,7 +212,7 @@ class NeutronScenarioTestCase(test.TestCase):
"admin_state_up": False
}
}
mock_clients("neutron").update_router.return_value = expected_router
self.clients("neutron").update_router.return_value = expected_router
router = {
"router": {
@ -236,31 +224,29 @@ class NeutronScenarioTestCase(test.TestCase):
router_update_args = {"name": "_updated", "admin_state_up": False}
result_router = scenario._update_router(router, router_update_args)
mock_clients("neutron").update_router.assert_called_once_with(
self.clients("neutron").update_router.assert_called_once_with(
router["router"]["id"], expected_router)
self.assertEqual(result_router, expected_router)
self._test_atomic_action_timer(scenario.atomic_actions(),
"neutron.update_router")
@mock.patch(NEUTRON_UTILS + "NeutronScenario.clients")
def test_delete_router(self, mock_clients):
def test_delete_router(self):
scenario = utils.NeutronScenario()
router = scenario._create_router({})
scenario._delete_router(router)
mock_clients("neutron").delete_router.assert_called_once_with(
self.clients("neutron").delete_router.assert_called_once_with(
router["router"]["id"])
self._test_atomic_action_timer(scenario.atomic_actions(),
"neutron.delete_router")
@mock.patch(NEUTRON_UTILS + "NeutronScenario.clients")
def test_remove_interface_router(self, mock_clients):
def test_remove_interface_router(self):
subnet = {"name": "subnet-name", "id": "subnet-id"}
router_data = {"id": 1}
scenario = utils.NeutronScenario()
router = scenario._create_router(router_data)
scenario._add_interface_router(subnet, router)
scenario._remove_interface_router(subnet, router)
mock_remove_router = mock_clients("neutron").remove_interface_router
mock_remove_router = self.clients("neutron").remove_interface_router
mock_remove_router.assert_called_once_with(
router["id"], {"subnet_id": subnet["id"]})
self._test_atomic_action_timer(scenario.atomic_actions(),
@ -271,8 +257,7 @@ class NeutronScenarioTestCase(test.TestCase):
self.assertEqual(utils.NeutronScenario.SUBNET_IP_VERSION, 4)
@mock.patch(NEUTRON_UTILS + "NeutronScenario._generate_random_name")
@mock.patch(NEUTRON_UTILS + "NeutronScenario.clients")
def test_create_port(self, mock_clients, mock_rand_name):
def test_create_port(self, mock_rand_name):
scenario = utils.NeutronScenario()
net_id = "network-id"
@ -289,31 +274,29 @@ class NeutronScenarioTestCase(test.TestCase):
# Defaults
port_create_args = {}
scenario._create_port(net, port_create_args)
mock_clients("neutron"
self.clients("neutron"
).create_port.assert_called_once_with(expected_port_args)
self._test_atomic_action_timer(scenario.atomic_actions(),
"neutron.create_port")
mock_clients("neutron").create_port.reset_mock()
self.clients("neutron").create_port.reset_mock()
# Custom options
port_args = {"admin_state_up": True}
expected_port_args["port"].update(port_args)
scenario._create_port(net, port_args)
mock_clients("neutron"
self.clients("neutron"
).create_port.assert_called_once_with(expected_port_args)
@mock.patch(NEUTRON_UTILS + "NeutronScenario.clients")
def test_list_ports(self, mock_clients):
def test_list_ports(self):
scenario = utils.NeutronScenario()
ports = [{"name": "port1"}, {"name": "port2"}]
mock_clients("neutron").list_ports.return_value = {"ports": ports}
self.clients("neutron").list_ports.return_value = {"ports": ports}
self.assertEqual(ports, scenario._list_ports())
self._test_atomic_action_timer(scenario.atomic_actions(),
"neutron.list_ports")
@mock.patch(NEUTRON_UTILS + "NeutronScenario.clients")
def test_update_port(self, mock_clients):
def test_update_port(self):
scenario = utils.NeutronScenario()
expected_port = {
"port": {
@ -323,7 +306,7 @@ class NeutronScenarioTestCase(test.TestCase):
"device_owner": "dummy_owner"
}
}
mock_clients("neutron").update_port.return_value = expected_port
self.clients("neutron").update_port.return_value = expected_port
port = {
"port": {
@ -340,14 +323,13 @@ class NeutronScenarioTestCase(test.TestCase):
}
result_port = scenario._update_port(port, port_update_args)
mock_clients("neutron").update_port.assert_called_once_with(
self.clients("neutron").update_port.assert_called_once_with(
port["port"]["id"], expected_port)
self.assertEqual(result_port, expected_port)
self._test_atomic_action_timer(scenario.atomic_actions(),
"neutron.update_port")
@mock.patch(NEUTRON_UTILS + "NeutronScenario.clients")
def test_delete_port(self, mock_clients):
def test_delete_port(self):
scenario = utils.NeutronScenario()
network = scenario._create_network({})
@ -409,9 +391,12 @@ class NeutronScenarioTestCase(test.TestCase):
{"allocation_pools": []},
"10.10.10.0/24")] * subnets_per_network)
class NeutronScenarioFunctionalTestCase(test.FakeClientsTestCase):
@mock.patch(NEUTRON_UTILS + "network_wrapper.generate_cidr")
def test_functional_create_network_and_subnets(self, mock_generate_cidr):
scenario = utils.NeutronScenario(clients=fakes.FakeClients())
scenario = utils.NeutronScenario()
network_create_args = {"name": "foo_network"}
subnet_create_args = {}
subnets_per_network = 5

View File

@ -16,8 +16,6 @@
import mock
from rally import exceptions as rally_exceptions
from rally import objects
from rally import osclients
from rally.plugins.openstack.scenarios.nova import servers
from tests.unit import fakes
from tests.unit import test
@ -27,7 +25,7 @@ NOVA_SERVERS_MODULE = "rally.plugins.openstack.scenarios.nova.servers"
NOVA_SERVERS = NOVA_SERVERS_MODULE + ".NovaServers"
class NovaServersTestCase(test.TestCase):
class NovaServersTestCase(test.ClientsTestCase):
def test_boot_rescue_unrescue(self):
actions = [{"rescue_unrescue": 5}]
@ -202,10 +200,7 @@ class NovaServersTestCase(test.TestCase):
scenario._delete_server.assert_called_once_with(fake_server,
force=False)
@mock.patch(NOVA_SERVERS_MODULE + ".NovaServers.clients")
def test_boot_and_delete_multiple_servers(self, mock_nova_clients):
mock_nova_clients.return_value = fakes.FakeNovaClient()
def test_boot_and_delete_multiple_servers(self):
scenario = servers.NovaServers()
scenario._boot_servers = mock.Mock()
scenario._delete_servers = mock.Mock()
@ -323,17 +318,10 @@ class NovaServersTestCase(test.TestCase):
scenario._delete_server.assert_called_once_with(fake_server,
force=False)
def _prepare_boot(self, mock_osclients, nic=None, assert_nic=False):
def _prepare_boot(self, nic=None, assert_nic=False):
fake_server = mock.MagicMock()
fc = fakes.FakeClients()
mock_osclients.Clients.return_value = fc
nova = fakes.FakeNovaClient()
fc.nova = lambda: nova
user_endpoint = objects.Endpoint("url", "user", "password", "tenant")
clients = osclients.Clients(user_endpoint)
scenario = servers.NovaServers(clients=clients)
scenario = servers.NovaServers()
scenario._boot_server = mock.MagicMock(return_value=fake_server)
scenario._generate_random_name = mock.MagicMock(return_value="name")
@ -345,35 +333,24 @@ class NovaServersTestCase(test.TestCase):
if nic:
kwargs["nics"] = nic
if assert_nic:
nova.networks.create("net-1")
self.clients("nova").networks.create("net-1")
expected_kwargs["nics"] = nic or [{"net-id": "net-2"}]
print(kwargs)
print(expected_kwargs)
return scenario, kwargs, expected_kwargs
def _verify_boot_server(self, mock_osclients, nic=None, assert_nic=False):
def _verify_boot_server(self, nic=None, assert_nic=False):
scenario, kwargs, expected_kwargs = self._prepare_boot(
mock_osclients=mock_osclients,
nic=nic, assert_nic=assert_nic)
scenario.boot_server("img", 0, **kwargs)
scenario._boot_server.assert_called_once_with(
"img", 0, auto_assign_nic=False, **expected_kwargs)
@mock.patch("rally.plugins.openstack.scenarios"
".nova.servers.NovaServers.clients")
@mock.patch("rally.benchmark.runner.osclients")
def test_boot_server_no_nics(self, mock_osclients, mock_nova_clients):
mock_nova_clients.return_value = fakes.FakeNovaClient()
self._verify_boot_server(mock_osclients=mock_osclients,
nic=None, assert_nic=False)
def test_boot_server_no_nics(self):
self._verify_boot_server(nic=None, assert_nic=False)
@mock.patch("rally.benchmark.runner.osclients")
def test_boot_server_with_nic(self, mock_osclients):
self._verify_boot_server(mock_osclients=mock_osclients,
nic=[{"net-id": "net-1"}], assert_nic=True)
def test_boot_server_with_nic(self):
self._verify_boot_server(nic=[{"net-id": "net-1"}], assert_nic=True)
def test_snapshot_server(self):
fake_server = object()

View File

@ -29,7 +29,7 @@ SCN = "rally.benchmark.scenarios.base"
CONF = cfg.CONF
class NovaScenarioTestCase(test.TestCase):
class NovaScenarioTestCase(test.ClientsTestCase):
def setUp(self):
super(NovaScenarioTestCase, self).setUp()
@ -86,10 +86,9 @@ class NovaScenarioTestCase(test.TestCase):
check_interval=chk_interval,
timeout=time_out)
@mock.patch(NOVA_UTILS + ".NovaScenario.clients")
def test__list_servers(self, mock_clients):
def test__list_servers(self):
servers_list = []
mock_clients("nova").servers.list.return_value = servers_list
self.clients("nova").servers.list.return_value = servers_list
nova_scenario = utils.NovaScenario()
return_servers_list = nova_scenario._list_servers(True)
self.assertEqual(servers_list, return_servers_list)
@ -98,9 +97,8 @@ class NovaScenarioTestCase(test.TestCase):
@mock.patch(SCN + ".Scenario._generate_random_name",
return_value="foo_server_name")
@mock.patch(NOVA_UTILS + ".NovaScenario.clients")
def test__boot_server(self, mock_clients, mock_generate_random_name):
mock_clients("nova").servers.create.return_value = self.server
def test__boot_server(self, mock_generate_random_name):
self.clients("nova").servers.create.return_value = self.server
nova_scenario = utils.NovaScenario(context={})
return_server = nova_scenario._boot_server("image_id",
"flavor_id")
@ -110,20 +108,18 @@ class NovaScenarioTestCase(test.TestCase):
CONF.benchmark.nova_server_boot_timeout)
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")])
self.assertEqual(self.wait_for.mock(), return_server)
mock_clients("nova").servers.create.assert_called_once_with(
self.clients("nova").servers.create.assert_called_once_with(
"foo_server_name", "image_id", "flavor_id")
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.boot_server")
@mock.patch(SCN + ".Scenario._generate_random_name",
return_value="foo_server_name")
@mock.patch(NOVA_UTILS + ".NovaScenario.clients")
def test__boot_server_with_network(self, mock_clients,
mock_generate_random_name):
mock_clients("nova").servers.create.return_value = self.server
def test__boot_server_with_network(self, mock_generate_random_name):
self.clients("nova").servers.create.return_value = self.server
networks = [{"id": "foo_id", "external": False},
{"id": "bar_id", "external": False}]
mock_clients("nova").networks.list.return_value = networks
self.clients("nova").networks.list.return_value = networks
nova_scenario = utils.NovaScenario(context={
"iteration": 3,
"config": {"users": {"tenants": 2}},
@ -136,16 +132,15 @@ class NovaScenarioTestCase(test.TestCase):
CONF.benchmark.nova_server_boot_poll_interval,
CONF.benchmark.nova_server_boot_timeout)
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")])
mock_clients("nova").servers.create.assert_called_once_with(
self.clients("nova").servers.create.assert_called_once_with(
"foo_server_name", "image_id", "flavor_id",
nics=[{"net-id": "bar_id"}])
self.assertEqual(self.wait_for.mock(), return_server)
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.boot_server")
@mock.patch(NOVA_UTILS + ".NovaScenario.clients")
def test__boot_server_with_network_exception(self, mock_clients):
mock_clients("nova").servers.create.return_value = self.server
def test__boot_server_with_network_exception(self):
self.clients("nova").servers.create.return_value = self.server
nova_scenario = utils.NovaScenario(
context={"tenant": {"networks": None}})
self.assertRaises(TypeError, nova_scenario._boot_server,
@ -154,10 +149,8 @@ class NovaScenarioTestCase(test.TestCase):
@mock.patch(SCN + ".Scenario._generate_random_name",
return_value="foo_server_name")
@mock.patch(NOVA_UTILS + ".NovaScenario.clients")
def test__boot_server_with_ssh(self, mock_clients,
mock_generate_random_name):
mock_clients("nova").servers.create.return_value = self.server
def test__boot_server_with_ssh(self, mock_generate_random_name):
self.clients("nova").servers.create.return_value = self.server
nova_scenario = utils.NovaScenario(context={
"user": {"secgroup": {"name": "test"}}}
)
@ -168,7 +161,7 @@ class NovaScenarioTestCase(test.TestCase):
CONF.benchmark.nova_server_boot_timeout)
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")])
self.assertEqual(self.wait_for.mock(), return_server)
mock_clients("nova").servers.create.assert_called_once_with(
self.clients("nova").servers.create.assert_called_once_with(
"foo_server_name", "image_id", "flavor_id",
security_groups=["test"])
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
@ -176,10 +169,8 @@ class NovaScenarioTestCase(test.TestCase):
@mock.patch(SCN + ".Scenario._generate_random_name",
return_value="foo_server_name")
@mock.patch(NOVA_UTILS + ".NovaScenario.clients")
def test__boot_server_with_sec_group(self, mock_clients,
mock_generate_random_name):
mock_clients("nova").servers.create.return_value = self.server
def test__boot_server_with_sec_group(self, mock_generate_random_name):
self.clients("nova").servers.create.return_value = self.server
nova_scenario = utils.NovaScenario(context={
"user": {"secgroup": {"name": "new"}}}
)
@ -192,7 +183,7 @@ class NovaScenarioTestCase(test.TestCase):
CONF.benchmark.nova_server_boot_timeout)
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")])
self.assertEqual(self.wait_for.mock(), return_server)
mock_clients("nova").servers.create.assert_called_once_with(
self.clients("nova").servers.create.assert_called_once_with(
"foo_server_name", "image_id", "flavor_id",
security_groups=["test", "new"])
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
@ -200,10 +191,9 @@ class NovaScenarioTestCase(test.TestCase):
@mock.patch(SCN + ".Scenario._generate_random_name",
return_value="foo_server_name")
@mock.patch(NOVA_UTILS + ".NovaScenario.clients")
def test__boot_server_with_similar_sec_group(self, mock_clients,
def test__boot_server_with_similar_sec_group(self,
mock_generate_random_name):
mock_clients("nova").servers.create.return_value = self.server
self.clients("nova").servers.create.return_value = self.server
nova_scenario = utils.NovaScenario(context={
"user": {"secgroup": {"name": "test1"}}}
)
@ -216,7 +206,7 @@ class NovaScenarioTestCase(test.TestCase):
CONF.benchmark.nova_server_boot_timeout)
self.res_is.mock.assert_has_calls([mock.call("ACTIVE")])
self.assertEqual(self.wait_for.mock(), return_server)
mock_clients("nova").servers.create.assert_called_once_with(
self.clients("nova").servers.create.assert_called_once_with(
"foo_server_name", "image_id", "flavor_id",
security_groups=["test1"])
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
@ -294,9 +284,8 @@ class NovaScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.unshelve_server")
@mock.patch(NOVA_UTILS + ".NovaScenario.clients")
def test__create_image(self, mock_clients):
mock_clients("nova").images.get.return_value = self.image
def test__create_image(self):
self.clients("nova").images.get.return_value = self.image
nova_scenario = utils.NovaScenario()
return_image = nova_scenario._create_image(self.server)
self._test_assert_called_once_with(
@ -416,8 +405,7 @@ class NovaScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.unrescue_server")
@mock.patch(NOVA_UTILS + ".NovaScenario.clients")
def _test_delete_servers(self, mock_clients, force=False):
def _test_delete_servers(self, force=False):
servers = [self.server, self.server1]
nova_scenario = utils.NovaScenario()
nova_scenario._delete_servers(servers, force=force)
@ -458,9 +446,8 @@ class NovaScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.delete_image")
@mock.patch(NOVA_UTILS + ".NovaScenario.clients")
def test__boot_servers(self, mock_clients):
mock_clients("nova").servers.list.return_value = [self.server,
def test__boot_servers(self):
self.clients("nova").servers.list.return_value = [self.server,
self.server1]
nova_scenario = utils.NovaScenario()
nova_scenario._boot_servers("image", "flavor", 2)
@ -529,10 +516,9 @@ class NovaScenarioTestCase(test.TestCase):
nova_scenario.check_ip_address(floating_ip, must_exist=False)
(fake_server))
@mock.patch(NOVA_UTILS + ".NovaScenario.clients")
def test__list_networks(self, mock_clients):
def test__list_networks(self):
network_list = []
mock_clients("nova").networks.list.return_value = network_list
self.clients("nova").networks.list.return_value = network_list
nova_scenario = utils.NovaScenario()
return_network_list = nova_scenario._list_networks()
self.assertEqual(network_list, return_network_list)
@ -558,27 +544,24 @@ class NovaScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.resize_revert")
@mock.patch(NOVA_UTILS + ".NovaScenario.clients")
def test__attach_volume(self, mock_clients):
mock_clients("nova").volumes.create_server_volume.return_value = None
def test__attach_volume(self):
self.clients("nova").volumes.create_server_volume.return_value = None
nova_scenario = utils.NovaScenario()
nova_scenario._attach_volume(self.server, self.volume)
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.attach_volume")
@mock.patch(NOVA_UTILS + ".NovaScenario.clients")
def test__detach_volume(self, mock_clients):
mock_clients("nova").volumes.delete_server_volume.return_value = None
def test__detach_volume(self):
self.clients("nova").volumes.delete_server_volume.return_value = None
nova_scenario = utils.NovaScenario()
nova_scenario._detach_volume(self.server, self.volume)
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.detach_volume")
@mock.patch(NOVA_UTILS + ".NovaScenario.clients")
def test__live_migrate_server(self, mock_clients):
def test__live_migrate_server(self):
fake_host = mock.MagicMock()
mock_clients("nova").servers.get(return_value=self.server)
nova_scenario = utils.NovaScenario(admin_clients=mock_clients)
self.admin_clients("nova").servers.get(return_value=self.server)
nova_scenario = utils.NovaScenario()
nova_scenario._live_migrate(self.server,
fake_host,
block_migration=False,
@ -593,14 +576,11 @@ class NovaScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.live_migrate")
@mock.patch(NOVA_UTILS + ".NovaScenario.admin_clients")
def test__find_host_to_migrate(self, mock_clients):
def test__find_host_to_migrate(self):
fake_server = self.server
fake_host = {"nova-compute": {"available": True}}
nova_client = mock.MagicMock()
mock_clients.return_value = nova_client
nova_client.servers.get.return_value = fake_server
nova_client.availability_zones.list.return_value = [
self.admin_clients("nova").servers.get.return_value = fake_server
self.admin_clients("nova").availability_zones.list.return_value = [
mock.MagicMock(zoneName="a",
hosts={"a1": fake_host, "a2": fake_host,
"a3": fake_host}),
@ -613,17 +593,16 @@ class NovaScenarioTestCase(test.TestCase):
]
setattr(fake_server, "OS-EXT-SRV-ATTR:host", "b2")
setattr(fake_server, "OS-EXT-AZ:availability_zone", "b")
nova_scenario = utils.NovaScenario(admin_clients=fakes.FakeClients())
nova_scenario = utils.NovaScenario()
self.assertIn(
nova_scenario._find_host_to_migrate(fake_server), ["b1", "b3"])
@mock.patch(NOVA_UTILS + ".NovaScenario.clients")
def test__migrate_server(self, mock_clients):
def test__migrate_server(self):
fake_server = self.server
setattr(fake_server, "OS-EXT-SRV-ATTR:host", "a1")
mock_clients("nova").servers.get(return_value=fake_server)
nova_scenario = utils.NovaScenario(admin_clients=mock_clients)
self.clients("nova").servers.get(return_value=fake_server)
nova_scenario = utils.NovaScenario()
nova_scenario._migrate(fake_server, skip_host_check=True)
self._test_assert_called_once_with(
@ -639,9 +618,7 @@ class NovaScenarioTestCase(test.TestCase):
fake_server, skip_host_check=False)
def test__create_security_groups(self):
clients = mock.MagicMock()
nova_scenario = utils.NovaScenario()
nova_scenario.clients = clients
nova_scenario._generate_random_name = mock.MagicMock()
security_group_count = 5
@ -649,20 +626,18 @@ class NovaScenarioTestCase(test.TestCase):
sec_groups = nova_scenario._create_security_groups(
security_group_count)
self.assertEqual(security_group_count, clients.call_count)
self.assertEqual(security_group_count, len(sec_groups))
self.assertEqual(security_group_count,
nova_scenario._generate_random_name.call_count)
self.assertEqual(security_group_count,
clients().security_groups.create.call_count)
self.assertEqual(
security_group_count,
self.clients("nova").security_groups.create.call_count)
self._test_atomic_action_timer(
nova_scenario.atomic_actions(),
"nova.create_%s_security_groups" % security_group_count)
def test__create_rules_for_security_group(self):
clients = mock.MagicMock()
nova_scenario = utils.NovaScenario()
nova_scenario.clients = clients
fake_secgroups = [fakes.FakeSecurityGroup(None, None, 1, "uuid1"),
fakes.FakeSecurityGroup(None, None, 2, "uuid2")]
@ -671,80 +646,66 @@ class NovaScenarioTestCase(test.TestCase):
nova_scenario._create_rules_for_security_group(
fake_secgroups, rules_per_security_group)
self.assertEqual(len(fake_secgroups) * rules_per_security_group,
clients.call_count)
self.assertEqual(len(fake_secgroups) * rules_per_security_group,
clients().security_group_rules.create.call_count)
self.assertEqual(
len(fake_secgroups) * rules_per_security_group,
self.clients("nova").security_group_rules.create.call_count)
self._test_atomic_action_timer(
nova_scenario.atomic_actions(),
"nova.create_%s_rules" %
(rules_per_security_group * len(fake_secgroups)))
def test__delete_security_groups(self):
clients = mock.MagicMock()
nova_scenario = utils.NovaScenario()
nova_scenario.clients = clients
fake_secgroups = [fakes.FakeSecurityGroup(None, None, 1, "uuid1"),
fakes.FakeSecurityGroup(None, None, 2, "uuid2")]
nova_scenario._delete_security_groups(fake_secgroups)
self.assertEqual(len(fake_secgroups), clients.call_count)
self.assertSequenceEqual(
map(lambda x: mock.call(x.id), fake_secgroups),
clients().security_groups.delete.call_args_list)
self.clients("nova").security_groups.delete.call_args_list)
self._test_atomic_action_timer(
nova_scenario.atomic_actions(),
"nova.delete_%s_security_groups" % len(fake_secgroups))
def test__list_security_groups(self):
clients = mock.MagicMock()
nova_scenario = utils.NovaScenario()
nova_scenario.clients = clients
nova_scenario._list_security_groups()
clients.assert_called_once_with("nova")
clients().security_groups.list.assert_called_once_with()
self.clients("nova").security_groups.list.assert_called_once_with()
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.list_security_groups")
@mock.patch(NOVA_UTILS + ".NovaScenario.clients")
def test__list_keypairs(self, mock_clients):
def test__list_keypairs(self):
keypairs_list = ["foo_keypair"]
mock_clients("nova").keypairs.list.return_value = keypairs_list
self.clients("nova").keypairs.list.return_value = keypairs_list
nova_scenario = utils.NovaScenario()
return_keypairs_list = nova_scenario._list_keypairs()
self.assertEqual(keypairs_list, return_keypairs_list)
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.list_keypairs")
@mock.patch(NOVA_UTILS + ".NovaScenario.clients")
def test__create_keypair(self, mock_clients):
(mock_clients("nova").keypairs.create.
return_value.name) = self.keypair
def test__create_keypair(self):
self.clients("nova").keypairs.create.return_value.name = self.keypair
nova_scenario = utils.NovaScenario()
return_keypair = nova_scenario._create_keypair()
self.assertEqual(self.keypair, return_keypair)
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.create_keypair")
@mock.patch(NOVA_UTILS + ".NovaScenario.clients")
def test__delete_keypair(self, mock_clients):
def test__delete_keypair(self):
nova_scenario = utils.NovaScenario()
nova_scenario._delete_keypair(self.keypair)
mock_clients("nova").keypairs.delete.assert_called_once_with(
self.clients("nova").keypairs.delete.assert_called_once_with(
self.keypair)
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.delete_keypair")
@mock.patch(NOVA_UTILS + ".NovaScenario.admin_clients")
def test__list_floating_ips_bulk(self, mock_clients):
def test__list_floating_ips_bulk(self):
floating_ips_bulk_list = ["foo_floating_ips_bulk"]
mock_clients("nova").floating_ips_bulk.list.return_value = (
self.admin_clients("nova").floating_ips_bulk.list.return_value = (
floating_ips_bulk_list)
nova_scenario = utils.NovaScenario()
return_floating_ips_bulk_list = nova_scenario._list_floating_ips_bulk()
@ -753,14 +714,13 @@ class NovaScenarioTestCase(test.TestCase):
"nova.list_floating_ips_bulk")
@mock.patch(NOVA_UTILS + ".network_wrapper.generate_cidr")
@mock.patch(NOVA_UTILS + ".NovaScenario.admin_clients")
def test__create_floating_ips_bulk(self, mock_clients, mock_gencidr):
def test__create_floating_ips_bulk(self, mock_gencidr):
fake_cidr = "10.2.0.0/24"
fake_pool = "test1"
fake_floating_ips_bulk = mock.MagicMock()
fake_floating_ips_bulk.ip_range = fake_cidr
fake_floating_ips_bulk.pool = fake_pool
mock_clients("nova").floating_ips_bulk.create.return_value = (
self.admin_clients("nova").floating_ips_bulk.create.return_value = (
fake_floating_ips_bulk)
nova_scenario = utils.NovaScenario()
return_iprange = nova_scenario._create_floating_ips_bulk(fake_cidr)
@ -769,21 +729,20 @@ class NovaScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.create_floating_ips_bulk")
@mock.patch(NOVA_UTILS + ".NovaScenario.admin_clients")
def test__delete_floating_ips_bulk(self, mock_clients):
def test__delete_floating_ips_bulk(self):
fake_cidr = "10.2.0.0/24"
nova_scenario = utils.NovaScenario()
nova_scenario._delete_floating_ips_bulk(fake_cidr)
mock_clients("nova").floating_ips_bulk.delete.assert_called_once_with(
fake_cidr)
self.admin_clients(
"nova").floating_ips_bulk.delete.assert_called_once_with(fake_cidr)
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.delete_floating_ips_bulk")
@mock.patch(NOVA_UTILS + ".NovaScenario.admin_clients")
def test__list_hypervisors(self, mock_clients):
def test__list_hypervisors(self):
nova_scenario = utils.NovaScenario()
nova_scenario._list_hypervisors(detailed=False)
mock_clients("nova").hypervisors.list.assert_called_once_with(False)
self.admin_clients("nova").hypervisors.list.assert_called_once_with(
False)
self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.list_hypervisors")

View File

@ -19,7 +19,7 @@ from rally.plugins.openstack.scenarios.quotas import quotas
from tests.unit import test
class QuotasTestCase(test.TestCase):
class QuotasTestCase(test.ClientsTestCase):
def setUp(self):
super(QuotasTestCase, self).setUp()
@ -56,12 +56,11 @@ class QuotasTestCase(test.TestCase):
scenario._update_quotas.assert_called_once_with("cinder", "fake", 1024)
scenario._delete_quotas.assert_called_once_with("cinder", "fake")
@mock.patch("rally.benchmark.scenarios.base.Scenario.admin_clients")
def test_neutron_update(self, mock_clients):
def test_neutron_update(self):
scenario = quotas.Quotas(self.context)
scenario._update_quotas = mock.MagicMock()
mock_quota_update_fn = mock_clients().update_quota
mock_quota_update_fn = self.admin_clients("neutron").update_quota
scenario.neutron_update(max_quota=1024)
scenario._update_quotas.assert_called_once_with("neutron", "fake",
1024,

View File

@ -17,14 +17,10 @@ import mock
import six
from rally.plugins.openstack.scenarios.quotas import utils
from tests.unit import fakes
from tests.unit import test
class QuotasScenarioTestCase(test.TestCase):
def setUp(self):
super(QuotasScenarioTestCase, self).setUp()
class QuotasScenarioTestCase(test.ClientsTestCase):
def test__update_quotas(self):
tenant_id = "fake_tenant"
@ -38,17 +34,15 @@ class QuotasScenarioTestCase(test.TestCase):
"injected_files": 10,
"cores": 10,
}
fake_nova = fakes.FakeNovaClient()
fake_nova.quotas.update = mock.MagicMock(return_value=quotas)
fake_clients = fakes.FakeClients()
fake_clients._nova = fake_nova
scenario = utils.QuotasScenario(admin_clients=fake_clients)
self.admin_clients("nova").quotas.update.return_value = quotas
scenario = utils.QuotasScenario()
scenario._generate_quota_values = mock.MagicMock(return_value=quotas)
result = scenario._update_quotas("nova", tenant_id)
self.assertEqual(quotas, result)
fake_nova.quotas.update.assert_called_once_with(tenant_id, **quotas)
self.admin_clients("nova").quotas.update.assert_called_once_with(
tenant_id, **quotas)
self._test_atomic_action_timer(scenario.atomic_actions(),
"quotas.update_quotas")
@ -64,11 +58,8 @@ class QuotasScenarioTestCase(test.TestCase):
"injected_files": 10,
"cores": 10,
}
fake_nova = fakes.FakeNovaClient()
fake_nova.quotas.update = mock.MagicMock(return_value=quotas)
fake_clients = fakes.FakeClients()
fake_clients._nova = fake_nova
scenario = utils.QuotasScenario(admin_clients=fake_clients)
self.admin_clients("nova").quotas.update.return_value = quotas
scenario = utils.QuotasScenario()
scenario._generate_quota_values = mock.MagicMock(return_value=quotas)
mock_quota = mock.Mock(return_value=quotas)
@ -82,21 +73,21 @@ class QuotasScenarioTestCase(test.TestCase):
def test__generate_quota_values_nova(self):
max_quota = 1024
scenario = utils.QuotasScenario(admin_clients=fakes.FakeClients())
scenario = utils.QuotasScenario()
quotas = scenario._generate_quota_values(max_quota, "nova")
for k, v in six.iteritems(quotas):
self.assertTrue(-1 <= v <= max_quota)
def test__generate_quota_values_cinder(self):
max_quota = 1024
scenario = utils.QuotasScenario(admin_clients=fakes.FakeClients())
scenario = utils.QuotasScenario()
quotas = scenario._generate_quota_values(max_quota, "cinder")
for k, v in six.iteritems(quotas):
self.assertTrue(-1 <= v <= max_quota)
def test__generate_quota_values_neutron(self):
max_quota = 1024
scenario = utils.QuotasScenario(admin_clients=fakes.FakeClients())
scenario = utils.QuotasScenario()
quotas = scenario._generate_quota_values(max_quota, "neutron")
for v in six.itervalues(quotas):
for v1 in six.itervalues(v):
@ -105,14 +96,10 @@ class QuotasScenarioTestCase(test.TestCase):
def test__delete_quotas(self):
tenant_id = "fake_tenant"
fake_nova = fakes.FakeNovaClient()
fake_nova.quotas.delete = mock.MagicMock()
fake_clients = fakes.FakeClients()
fake_clients._nova = fake_nova
scenario = utils.QuotasScenario(admin_clients=fake_clients)
scenario = utils.QuotasScenario()
scenario._delete_quotas("nova", tenant_id)
fake_nova.quotas.delete.assert_called_once_with(tenant_id)
self.admin_clients("nova").quotas.delete.assert_called_once_with(
tenant_id)
self._test_atomic_action_timer(scenario.atomic_actions(),
"quotas.delete_quotas")

View File

@ -23,15 +23,13 @@ SAHARA_CLUSTERS = ("rally.plugins.openstack.scenarios.sahara.clusters"
SAHARA_UTILS = "rally.plugins.openstack.scenarios.sahara.utils"
class SaharaClustersTestCase(test.TestCase):
class SaharaClustersTestCase(test.ClientsTestCase):
@mock.patch(SAHARA_CLUSTERS + "._delete_cluster")
@mock.patch(SAHARA_CLUSTERS + "._launch_cluster",
return_value=mock.MagicMock(id=42))
@mock.patch(SAHARA_UTILS + ".SaharaScenario.clients")
def test_create_and_delete_cluster(self, mock_clients, mock_launch_cluster,
def test_create_and_delete_cluster(self, mock_launch_cluster,
mock_delete_cluster):
clusters_scenario = clusters.SaharaClusters()
clusters_scenario.context = {
@ -67,14 +65,10 @@ class SaharaClustersTestCase(test.TestCase):
@mock.patch(SAHARA_CLUSTERS + "._scale_cluster")
@mock.patch(SAHARA_CLUSTERS + "._launch_cluster",
return_value=mock.MagicMock(id=42))
@mock.patch(SAHARA_UTILS + ".SaharaScenario.clients")
def test_create_scale_delete_cluster(self, mock_clients,
mock_launch_cluster,
def test_create_scale_delete_cluster(self, mock_launch_cluster,
mock_scale_cluster,
mock_delete_cluster):
mock_sahara = mock_clients("sahara")
mock_sahara.clusters.get.return_value = mock.MagicMock(
self.clients("sahara").clusters.get.return_value = mock.MagicMock(
id=42, status="active"
)
clusters_scenario = clusters.SaharaClusters()
@ -108,9 +102,9 @@ class SaharaClustersTestCase(test.TestCase):
enable_anti_affinity=False)
mock_scale_cluster.assert_has_calls([
mock.call(mock_sahara.clusters.get.return_value, 1),
mock.call(mock_sahara.clusters.get.return_value, -1),
mock.call(self.clients("sahara").clusters.get.return_value, 1),
mock.call(self.clients("sahara").clusters.get.return_value, -1),
])
mock_delete_cluster.assert_called_once_with(
mock_sahara.clusters.get.return_value)
self.clients("sahara").clusters.get.return_value)

View File

@ -25,7 +25,7 @@ SAHARA_JOB = "rally.plugins.openstack.scenarios.sahara.jobs.SaharaJob"
SAHARA_UTILS = "rally.plugins.openstack.scenarios.sahara.utils"
class SaharaJobTestCase(test.TestCase):
class SaharaJobTestCase(test.ClientsTestCase):
def setUp(self):
super(SaharaJobTestCase, self).setUp()
@ -36,12 +36,10 @@ class SaharaJobTestCase(test.TestCase):
@mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name",
return_value="job_42")
@mock.patch(SAHARA_JOB + "._run_job_execution")
@mock.patch(SAHARA_UTILS + ".SaharaScenario.clients")
def test_create_launch_job_java(self, mock_osclients, mock_run_execution,
def test_create_launch_job_java(self, mock_run_execution,
mock_random_name):
mock_sahara = mock_osclients("sahara")
mock_sahara.jobs.create.return_value = mock.MagicMock(id="42")
self.clients("sahara").jobs.create.return_value = mock.MagicMock(
id="42")
jobs_scenario = jobs.SaharaJob()
@ -59,7 +57,7 @@ class SaharaJobTestCase(test.TestCase):
configs={"conf_key": "conf_val"},
job_idx=0
)
mock_sahara.jobs.create.assert_called_once_with(
self.clients("sahara").jobs.create.assert_called_once_with(
name=mock_random_name.return_value,
type="java",
description="",
@ -81,12 +79,10 @@ class SaharaJobTestCase(test.TestCase):
@mock.patch(SAHARA_JOB + "._run_job_execution")
@mock.patch(SAHARA_JOB + "._create_output_ds",
return_value=mock.MagicMock(id="out_42"))
@mock.patch(SAHARA_UTILS + ".SaharaScenario.clients")
def test_create_launch_job_pig(self, mock_osclients, mock_create_ds,
def test_create_launch_job_pig(self, mock_create_ds,
mock_run_execution, mock_random_name):
mock_sahara = mock_osclients("sahara")
mock_sahara.jobs.create.return_value = mock.MagicMock(id="42")
self.clients("sahara").jobs.create.return_value = mock.MagicMock(
id="42")
jobs_scenario = jobs.SaharaJob()
@ -104,7 +100,7 @@ class SaharaJobTestCase(test.TestCase):
configs={"conf_key": "conf_val"},
job_idx=0
)
mock_sahara.jobs.create.assert_called_once_with(
self.clients("sahara").jobs.create.assert_called_once_with(
name=mock_random_name.return_value,
type="pig",
description="",
@ -124,12 +120,10 @@ class SaharaJobTestCase(test.TestCase):
@mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name",
return_value="job_42")
@mock.patch(SAHARA_JOB + "._run_job_execution")
@mock.patch(SAHARA_UTILS + ".SaharaScenario.clients")
def test_create_launch_job_sequence(self, mock_osclients,
mock_run_execution, mock_random_name):
mock_sahara = mock_osclients("sahara")
mock_sahara.jobs.create.return_value = mock.MagicMock(id="42")
def test_create_launch_job_sequence(self, mock_run_execution,
mock_random_name):
self.clients("sahara").jobs.create.return_value = mock.MagicMock(
id="42")
jobs_scenario = jobs.SaharaJob()
@ -159,8 +153,8 @@ class SaharaJobTestCase(test.TestCase):
mains=["main_42"],
libs=["lib_42"])
mock_sahara.jobs.create.assert_has_calls([jobs_create_call,
jobs_create_call])
self.clients("sahara").jobs.create.assert_has_calls([jobs_create_call,
jobs_create_call])
mock_run_execution.assert_has_calls([
mock.call(
@ -183,15 +177,12 @@ class SaharaJobTestCase(test.TestCase):
return_value="job_42")
@mock.patch(SAHARA_JOB + "._run_job_execution")
@mock.patch(SAHARA_JOB + "._scale_cluster")
@mock.patch(SAHARA_UTILS + ".SaharaScenario.clients")
def test_create_launch_job_sequence_with_scaling(self, mock_osclients,
mock_scale,
def test_create_launch_job_sequence_with_scaling(self, mock_scale,
mock_run_execution,
mock_random_name):
mock_sahara = mock_osclients("sahara")
mock_sahara.jobs.create.return_value = mock.MagicMock(id="42")
mock_sahara.clusters.get.return_value = mock.MagicMock(
self.clients("sahara").jobs.create.return_value = mock.MagicMock(
id="42")
self.clients("sahara").clusters.get.return_value = mock.MagicMock(
id="cl_42",
status="active")
@ -224,8 +215,8 @@ class SaharaJobTestCase(test.TestCase):
mains=["main_42"],
libs=["lib_42"])
mock_sahara.jobs.create.assert_has_calls([jobs_create_call,
jobs_create_call])
self.clients("sahara").jobs.create.assert_has_calls([jobs_create_call,
jobs_create_call])
je_0 = mock.call(job_id="42", cluster_id="cl_42", input_id=None,
output_id=None, configs={"conf_key": "conf_val"},

View File

@ -28,7 +28,7 @@ CONF = cfg.CONF
SAHARA_UTILS = "rally.plugins.openstack.scenarios.sahara.utils"
class SaharaUtilsTestCase(test.TestCase):
class SaharaUtilsTestCase(test.ClientsTestCase):
def setUp(self):
super(SaharaUtilsTestCase, self).setUp()
@ -36,10 +36,9 @@ class SaharaUtilsTestCase(test.TestCase):
CONF.set_override("cluster_check_interval", 0, "benchmark")
CONF.set_override("job_check_interval", 0, "benchmark")
@mock.patch(SAHARA_UTILS + ".SaharaScenario.clients")
def test_list_node_group_templates(self, mock_clients):
def test_list_node_group_templates(self):
ngts = []
mock_clients("sahara").node_group_templates.list.return_value = ngts
self.clients("sahara").node_group_templates.list.return_value = ngts
scenario = utils.SaharaScenario()
return_ngts_list = scenario._list_node_group_templates()
@ -50,11 +49,9 @@ class SaharaUtilsTestCase(test.TestCase):
@mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name",
return_value="random_name")
@mock.patch(SAHARA_UTILS + ".SaharaScenario.clients")
@mock.patch(SAHARA_UTILS + ".sahara_consts")
def test_create_node_group_templates(self, mock_constants, mock_clients,
def test_create_node_group_templates(self, mock_constants,
mock_random_name):
scenario = utils.SaharaScenario()
mock_processes = {
"test_plugin": {
@ -92,7 +89,7 @@ class SaharaUtilsTestCase(test.TestCase):
flavor_id="test_flavor",
node_processes=["p2"]
)]
mock_clients("sahara").node_group_templates.create.assert_has_calls(
self.clients("sahara").node_group_templates.create.assert_has_calls(
create_calls)
self._test_atomic_action_timer(
@ -102,15 +99,13 @@ class SaharaUtilsTestCase(test.TestCase):
scenario.atomic_actions(),
"sahara.create_worker_node_group_template")
@mock.patch(SAHARA_UTILS + ".SaharaScenario.clients")
def test_delete_node_group_templates(self, mock_clients):
def test_delete_node_group_templates(self):
scenario = utils.SaharaScenario()
ng = mock.MagicMock(id=42)
scenario._delete_node_group_template(ng)
delete_mock = mock_clients("sahara").node_group_templates.delete
delete_mock = self.clients("sahara").node_group_templates.delete
delete_mock.assert_called_once_with(42)
self._test_atomic_action_timer(scenario.atomic_actions(),
@ -118,14 +113,8 @@ class SaharaUtilsTestCase(test.TestCase):
@mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name",
return_value="random_name")
@mock.patch(SAHARA_UTILS + ".SaharaScenario.clients")
@mock.patch(SAHARA_UTILS + ".sahara_consts")
def test_launch_cluster(self, mock_constants,
mock_clients, mock_random_name):
clients_values = mock.MagicMock(return_value=[consts.Service.NEUTRON])
mock_clients.services.return_value = mock.MagicMock(
values=clients_values)
def test_launch_cluster(self, mock_constants, mock_random_name):
context = {
"tenant": {
@ -138,7 +127,10 @@ class SaharaUtilsTestCase(test.TestCase):
}
}
scenario = utils.SaharaScenario(context=context, clients=mock_clients)
clients = mock.Mock(services=mock.Mock(
return_value={"neutron": consts.Service.NEUTRON}))
scenario = utils.SaharaScenario(context=context,
clients=clients)
mock_processes = {
"test_plugin": {
@ -188,10 +180,10 @@ class SaharaUtilsTestCase(test.TestCase):
mock_constants.NODE_PROCESSES = mock_processes
mock_constants.REPLICATION_CONFIGS = mock_configs
mock_clients("sahara").clusters.create.return_value = mock.MagicMock(
self.clients("sahara").clusters.create.return_value = mock.MagicMock(
id="test_cluster_id")
mock_clients("sahara").clusters.get.return_value = mock.MagicMock(
self.clients("sahara").clusters.get.return_value = mock.MagicMock(
status="active")
scenario._launch_cluster(
@ -208,7 +200,7 @@ class SaharaUtilsTestCase(test.TestCase):
node_configs={"HDFS": {"local_config": "local_value"}}
)
mock_clients("sahara").clusters.create.assert_called_once_with(
self.clients("sahara").clusters.create.assert_called_once_with(
name="random_name",
plugin_name="test_plugin",
hadoop_version="test_version",
@ -224,11 +216,8 @@ class SaharaUtilsTestCase(test.TestCase):
@mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name",
return_value="random_name")
@mock.patch(SAHARA_UTILS + ".SaharaScenario.clients")
@mock.patch(SAHARA_UTILS + ".sahara_consts")
def test_launch_cluster_error(self, mock_constants, mock_clients,
mock_random_name):
def test_launch_cluster_error(self, mock_constants, mock_random_name):
scenario = utils.SaharaScenario(clients=mock.MagicMock())
mock_processes = {
"test_plugin": {
@ -251,10 +240,10 @@ class SaharaUtilsTestCase(test.TestCase):
mock_constants.NODE_PROCESSES = mock_processes
mock_constants.REPLICATION_CONFIGS = mock_configs
mock_clients("sahara").clusters.create.return_value = mock.MagicMock(
self.clients("sahara").clusters.create.return_value = mock.MagicMock(
id="test_cluster_id")
mock_clients("sahara").clusters.get.return_value = mock.MagicMock(
self.clients("sahara").clusters.get.return_value = mock.MagicMock(
status="error")
self.assertRaises(exceptions.SaharaClusterFailure,
@ -270,9 +259,7 @@ class SaharaUtilsTestCase(test.TestCase):
node_configs={"HDFS": {"local_config":
"local_value"}})
@mock.patch(SAHARA_UTILS + ".SaharaScenario.clients")
def test_scale_cluster(self, mock_clients):
def test_scale_cluster(self):
scenario = utils.SaharaScenario()
cluster = mock.MagicMock(id=42, node_groups=[{
"name": "random_master",
@ -281,7 +268,7 @@ class SaharaUtilsTestCase(test.TestCase):
"name": "random_worker",
"count": 41
}])
mock_clients("sahara").clusters.get.return_value = mock.MagicMock(
self.clients("sahara").clusters.get.return_value = mock.MagicMock(
id=42,
status="active")
@ -293,25 +280,22 @@ class SaharaUtilsTestCase(test.TestCase):
}
scenario._scale_cluster(cluster, 1)
mock_clients("sahara").clusters.scale.assert_called_once_with(
self.clients("sahara").clusters.scale.assert_called_once_with(
42, expected_scale_object)
@mock.patch(SAHARA_UTILS + ".SaharaScenario.clients")
def test_delete_cluster(self, mock_clients):
def test_delete_cluster(self):
scenario = utils.SaharaScenario()
cluster = mock.MagicMock(id=42)
mock_clients("sahara").clusters.get.side_effect = [
self.clients("sahara").clusters.get.side_effect = [
cluster, sahara_base.APIException()
]
scenario._delete_cluster(cluster)
delete_mock = mock_clients("sahara").clusters.delete
delete_mock = self.clients("sahara").clusters.delete
delete_mock.assert_called_once_with(42)
cl_get_expected = mock.call(42)
mock_clients("sahara").clusters.get.assert_has_calls([cl_get_expected,
self.clients("sahara").clusters.get.assert_has_calls([cl_get_expected,
cl_get_expected])
self._test_atomic_action_timer(scenario.atomic_actions(),
@ -319,9 +303,7 @@ class SaharaUtilsTestCase(test.TestCase):
@mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name",
return_value="42")
@mock.patch(SAHARA_UTILS + ".SaharaScenario.clients")
def test_create_output_ds(self, mock_clients, mock_random_name):
def test_create_output_ds(self, mock_random_name):
ctxt = {
"sahara_output_conf": {
"output_type": "hdfs",
@ -332,7 +314,7 @@ class SaharaUtilsTestCase(test.TestCase):
scenario = utils.SaharaScenario(ctxt)
scenario._create_output_ds()
mock_clients("sahara").data_sources.create.assert_called_once_with(
self.clients("sahara").data_sources.create.assert_called_once_with(
name="42",
description="",
data_source_type="hdfs",
@ -341,9 +323,7 @@ class SaharaUtilsTestCase(test.TestCase):
@mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name",
return_value="42")
@mock.patch(SAHARA_UTILS + ".SaharaScenario.clients")
def test_create_output_ds_swift(self, mock_clients, mock_random_name):
def test_create_output_ds_swift(self, mock_random_name):
ctxt = {
"sahara_output_conf": {
"output_type": "swift",
@ -355,14 +335,12 @@ class SaharaUtilsTestCase(test.TestCase):
self.assertRaises(exceptions.RallyException,
scenario._create_output_ds)
@mock.patch(SAHARA_UTILS + ".SaharaScenario.clients")
def test_run_job_execution(self, mock_clients):
mock_clients("sahara").job_executions.get.side_effect = [
def test_run_job_execution(self):
self.clients("sahara").job_executions.get.side_effect = [
mock.MagicMock(info={"status": "pending"}, id="42"),
mock.MagicMock(info={"status": "SUCCESS"}, id="42")]
mock_clients("sahara").job_executions.create.return_value = (
self.clients("sahara").job_executions.create.return_value = (
mock.MagicMock(id="42"))
scenario = utils.SaharaScenario()
@ -373,7 +351,7 @@ class SaharaUtilsTestCase(test.TestCase):
configs={"k": "v"},
job_idx=0)
mock_clients("sahara").job_executions.create.assert_called_once_with(
self.clients("sahara").job_executions.create.assert_called_once_with(
job_id="test_job_id",
cluster_id="test_cluster_id",
input_id="test_input_id",
@ -382,18 +360,16 @@ class SaharaUtilsTestCase(test.TestCase):
)
je_get_expected = mock.call("42")
mock_clients("sahara").job_executions.get.assert_has_calls(
self.clients("sahara").job_executions.get.assert_has_calls(
[je_get_expected, je_get_expected]
)
@mock.patch(SAHARA_UTILS + ".SaharaScenario.clients")
def test_run_job_execution_fail(self, mock_clients):
mock_clients("sahara").job_executions.get.side_effect = [
def test_run_job_execution_fail(self):
self.clients("sahara").job_executions.get.side_effect = [
mock.MagicMock(info={"status": "pending"}, id="42"),
mock.MagicMock(info={"status": "killed"}, id="42")]
mock_clients("sahara").job_executions.create.return_value = (
self.clients("sahara").job_executions.create.return_value = (
mock.MagicMock(id="42"))
scenario = utils.SaharaScenario()
@ -406,7 +382,7 @@ class SaharaUtilsTestCase(test.TestCase):
configs={"k": "v"},
job_idx=0)
mock_clients("sahara").job_executions.create.assert_called_once_with(
self.clients("sahara").job_executions.create.assert_called_once_with(
job_id="test_job_id",
cluster_id="test_cluster_id",
input_id="test_input_id",

View File

@ -16,11 +16,10 @@
import mock
from rally.plugins.openstack.scenarios.swift import objects
from tests.unit import fakes
from tests.unit import test
class SwiftObjectsTestCase(test.TestCase):
class SwiftObjectsTestCase(test.ClientsTestCase):
def test_create_container_and_object_then_list_objects(self):
scenario = objects.SwiftObjects()
@ -88,7 +87,7 @@ class SwiftObjectsTestCase(test.TestCase):
def test_functional_create_container_and_object_then_list_objects(self):
names_list = ["AA", "BB", "CC", "DD"]
scenario = objects.SwiftObjects(clients=fakes.FakeClients())
scenario = objects.SwiftObjects()
scenario._generate_random_name = mock.MagicMock(side_effect=names_list)
scenario._list_objects = mock.MagicMock()
@ -104,7 +103,7 @@ class SwiftObjectsTestCase(test.TestCase):
def test_functional_create_container_and_object_then_delete_all(self):
names_list = ["111", "222", "333", "444", "555"]
scenario = objects.SwiftObjects(clients=fakes.FakeClients())
scenario = objects.SwiftObjects()
scenario._generate_random_name = mock.MagicMock(side_effect=names_list)
scenario._delete_object = mock.MagicMock()
scenario._delete_container = mock.MagicMock()
@ -126,7 +125,7 @@ class SwiftObjectsTestCase(test.TestCase):
def test_functional_create_container_and_object_then_download_object(self):
names_list = ["aaa", "bbb", "ccc", "ddd", "eee", "fff"]
scenario = objects.SwiftObjects(clients=fakes.FakeClients())
scenario = objects.SwiftObjects()
scenario._generate_random_name = mock.MagicMock(side_effect=names_list)
scenario._download_object = mock.MagicMock()

View File

@ -21,26 +21,24 @@ from tests.unit import test
SWIFT_UTILS = "rally.plugins.openstack.scenarios.swift.utils"
class SwiftScenarioTestCase(test.TestCase):
class SwiftScenarioTestCase(test.ClientsTestCase):
@mock.patch(SWIFT_UTILS + ".SwiftScenario.clients")
def test__list_containers(self, mock_clients):
def test__list_containers(self):
headers_dict = mock.MagicMock()
containers_list = mock.MagicMock()
mock_clients("swift").get_account.return_value = (headers_dict,
self.clients("swift").get_account.return_value = (headers_dict,
containers_list)
scenario = utils.SwiftScenario()
self.assertEqual((headers_dict, containers_list),
scenario._list_containers(fargs="f"))
kw = {"full_listing": True, "fargs": "f"}
mock_clients("swift").get_account.assert_called_once_with(**kw)
self.clients("swift").get_account.assert_called_once_with(**kw)
self._test_atomic_action_timer(scenario.atomic_actions(),
"swift.list_containers")
@mock.patch(SWIFT_UTILS + ".SwiftScenario.clients")
def test__create_container(self, mock_clients):
def test__create_container(self):
container_name = mock.MagicMock()
scenario = utils.SwiftScenario()
@ -49,11 +47,11 @@ class SwiftScenarioTestCase(test.TestCase):
scenario._create_container(container_name,
public=True, fargs="f"))
kw = {"headers": {"X-Container-Read": ".r:*,.rlistings"}, "fargs": "f"}
mock_clients("swift").put_container.assert_called_once_with(
self.clients("swift").put_container.assert_called_once_with(
container_name,
**kw)
# name + public=True + additional header + kw
mock_clients("swift").put_container.reset_mock()
self.clients("swift").put_container.reset_mock()
self.assertEqual(container_name,
scenario._create_container(container_name,
public=True,
@ -62,11 +60,11 @@ class SwiftScenarioTestCase(test.TestCase):
fargs="f"))
kw = {"headers": {"X-Container-Read": ".r:*,.rlistings",
"X-fake-name": "fake-value"}, "fargs": "f"}
mock_clients("swift").put_container.assert_called_once_with(
self.clients("swift").put_container.assert_called_once_with(
container_name,
**kw)
# name + public=False + additional header + kw
mock_clients("swift").put_container.reset_mock()
self.clients("swift").put_container.reset_mock()
self.assertEqual(container_name,
scenario._create_container(container_name,
public=False,
@ -74,25 +72,25 @@ class SwiftScenarioTestCase(test.TestCase):
"fake-value"},
fargs="f"))
kw = {"headers": {"X-fake-name": "fake-value"}, "fargs": "f"}
mock_clients("swift").put_container.assert_called_once_with(
self.clients("swift").put_container.assert_called_once_with(
container_name,
**kw)
# name + kw
mock_clients("swift").put_container.reset_mock()
self.clients("swift").put_container.reset_mock()
self.assertEqual(container_name,
scenario._create_container(container_name, fargs="f"))
kw = {"fargs": "f"}
mock_clients("swift").put_container.assert_called_once_with(
self.clients("swift").put_container.assert_called_once_with(
container_name,
**kw)
# kw
scenario._generate_random_name = mock.MagicMock(
return_value=container_name)
mock_clients("swift").put_container.reset_mock()
self.clients("swift").put_container.reset_mock()
self.assertEqual(container_name,
scenario._create_container(fargs="f"))
kw = {"fargs": "f"}
mock_clients("swift").put_container.assert_called_once_with(
self.clients("swift").put_container.assert_called_once_with(
container_name,
**kw)
self.assertEqual(1, scenario._generate_random_name.call_count)
@ -100,46 +98,43 @@ class SwiftScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(scenario.atomic_actions(),
"swift.create_container")
@mock.patch(SWIFT_UTILS + ".SwiftScenario.clients")
def test__delete_container(self, mock_clients):
def test__delete_container(self):
container_name = mock.MagicMock()
scenario = utils.SwiftScenario()
scenario._delete_container(container_name, fargs="f")
kw = {"fargs": "f"}
mock_clients("swift").delete_container.assert_called_once_with(
self.clients("swift").delete_container.assert_called_once_with(
container_name,
**kw)
self._test_atomic_action_timer(scenario.atomic_actions(),
"swift.delete_container")
@mock.patch(SWIFT_UTILS + ".SwiftScenario.clients")
def test__list_objects(self, mock_clients):
def test__list_objects(self):
container_name = mock.MagicMock()
headers_dict = mock.MagicMock()
objects_list = mock.MagicMock()
mock_clients("swift").get_container.return_value = (headers_dict,
self.clients("swift").get_container.return_value = (headers_dict,
objects_list)
scenario = utils.SwiftScenario()
self.assertEqual((headers_dict, objects_list),
scenario._list_objects(container_name, fargs="f"))
kw = {"full_listing": True, "fargs": "f"}
mock_clients("swift").get_container.assert_called_once_with(
self.clients("swift").get_container.assert_called_once_with(
container_name,
**kw)
self._test_atomic_action_timer(scenario.atomic_actions(),
"swift.list_objects")
@mock.patch(SWIFT_UTILS + ".SwiftScenario.clients")
def test__upload_object(self, mock_clients):
def test__upload_object(self):
container_name = mock.MagicMock()
object_name = mock.MagicMock()
content = mock.MagicMock()
etag = mock.MagicMock()
mock_clients("swift").put_object.return_value = etag
self.clients("swift").put_object.return_value = etag
scenario = utils.SwiftScenario()
# container + content + name + kw
@ -148,18 +143,18 @@ class SwiftScenarioTestCase(test.TestCase):
object_name=object_name,
fargs="f"))
kw = {"fargs": "f"}
mock_clients("swift").put_object.assert_called_once_with(
self.clients("swift").put_object.assert_called_once_with(
container_name, object_name,
content, **kw)
# container + content + kw
scenario._generate_random_name = mock.MagicMock(
return_value=object_name)
mock_clients("swift").put_object.reset_mock()
self.clients("swift").put_object.reset_mock()
self.assertEqual((etag, object_name),
scenario._upload_object(container_name, content,
fargs="f"))
kw = {"fargs": "f"}
mock_clients("swift").put_object.assert_called_once_with(
self.clients("swift").put_object.assert_called_once_with(
container_name, object_name,
content, **kw)
self.assertEqual(1, scenario._generate_random_name.call_count)
@ -167,35 +162,33 @@ class SwiftScenarioTestCase(test.TestCase):
self._test_atomic_action_timer(scenario.atomic_actions(),
"swift.upload_object")
@mock.patch(SWIFT_UTILS + ".SwiftScenario.clients")
def test__download_object(self, mock_clients):
def test__download_object(self):
container_name = mock.MagicMock()
object_name = mock.MagicMock()
headers_dict = mock.MagicMock()
content = mock.MagicMock()
mock_clients("swift").get_object.return_value = (headers_dict, content)
self.clients("swift").get_object.return_value = (headers_dict, content)
scenario = utils.SwiftScenario()
self.assertEqual((headers_dict, content),
scenario._download_object(container_name, object_name,
fargs="f"))
kw = {"fargs": "f"}
mock_clients("swift").get_object.assert_called_once_with(
self.clients("swift").get_object.assert_called_once_with(
container_name, object_name,
**kw)
self._test_atomic_action_timer(scenario.atomic_actions(),
"swift.download_object")
@mock.patch(SWIFT_UTILS + ".SwiftScenario.clients")
def test__delete_object(self, mock_clients):
def test__delete_object(self):
container_name = mock.MagicMock()
object_name = mock.MagicMock()
scenario = utils.SwiftScenario()
scenario._delete_object(container_name, object_name, fargs="f")
kw = {"fargs": "f"}
mock_clients("swift").delete_object.assert_called_once_with(
self.clients("swift").delete_object.assert_called_once_with(
container_name, object_name,
**kw)
self._test_atomic_action_timer(scenario.atomic_actions(),

View File

@ -21,24 +21,16 @@ from tests.unit import test
UTILS = "rally.plugins.openstack.scenarios.zaqar.utils."
class ZaqarScenarioTestCase(test.TestCase):
class ZaqarScenarioTestCase(test.ClientsTestCase):
@mock.patch(UTILS + "ZaqarScenario._generate_random_name",
return_value="kitkat")
def test_queue_create(self, mock_gen_name):
queue = {}
fake_zaqar = fakes.FakeZaqarClient()
fake_zaqar.queue = mock.MagicMock(return_value=queue)
fake_clients = fakes.FakeClients()
fake_clients._zaqar = fake_zaqar
scenario = utils.ZaqarScenario(clients=fake_clients)
scenario = utils.ZaqarScenario()
result = scenario._queue_create(name_length=10)
self.assertEqual(queue, result)
fake_zaqar.queue.assert_called_once_with("kitkat")
self.assertEqual(self.clients("zaqar").queue.return_value, result)
self.clients("zaqar").queue.assert_called_once_with("kitkat")
self._test_atomic_action_timer(scenario.atomic_actions(),
"zaqar.create_queue")

View File

@ -20,6 +20,7 @@ from oslo_config import fixture
from oslotest import base
from rally import db
from tests.unit import fakes
class DatabaseFixture(fixture.Config):
@ -55,3 +56,64 @@ class DBTestCase(TestCase):
def setUp(self):
super(DBTestCase, self).setUp()
self.useFixture(DatabaseFixture())
class ClientsTestCase(TestCase):
"""Base class for Scenario tests using mocked self.clients."""
def client_factory(self, client_type, version=None, admin=False):
"""Create a new client object."""
return mock.MagicMock(client_type=client_type,
version=version,
admin=admin)
def clients(self, client_type, version=None, admin=False):
"""Get a mocked client."""
key = (client_type, version, admin)
if key not in self._clients:
self._clients[key] = self.client_factory(client_type,
version=version,
admin=admin)
return self._clients[key]
def admin_clients(self, client_type, version=None):
"""Get a mocked admin client."""
return self.clients(client_type, version=version, admin=True)
def client_created(self, client_type, version=None, admin=False):
"""Determine if a client has been created.
This can be used to see if a scenario calls
'self.clients("foo")', without checking to see what was done
with the client object returned by that call.
"""
key = (client_type, version, admin)
return key in self._clients
def setUp(self):
super(ClientsTestCase, self).setUp()
self._clients = {}
self._client_mocks = [
mock.patch("rally.benchmark.scenarios.base.Scenario.clients",
mock.Mock(side_effect=self.clients)),
mock.patch("rally.benchmark.scenarios.base.Scenario.admin_clients",
mock.Mock(side_effect=self.admin_clients))
]
for patcher in self._client_mocks:
patcher.start()
def tearDown(self):
for patcher in self._client_mocks:
patcher.stop()
super(ClientsTestCase, self).tearDown()
class FakeClientsTestCase(ClientsTestCase):
"""Base class for Scenario tests using fake (not mocked) self.clients."""
def client_factory(self, client_type, version=None, admin=False):
return getattr(self._fake_clients, client_type)()
def setUp(self):
super(FakeClientsTestCase, self).setUp()
self._fake_clients = fakes.FakeClients()