openstack/rally
Code Issues Proposed changes

Use cls instances instead of object in benchmarks

Browse Source 
Using @classmethod as a base for scenarios was actually caused
by historical reasons (of using pytest as a base for benchmarks)
As we don't use it anymore (for a long time) we are able to simplify
benchmark framework and use cls instances and plain methods.

This is only the first step. That just make required changes and fix
unit tests. In next patchset I will refactor & clean exisitng unit tests.

blueprint refactor-scenarios-to-use-class-instances

Change-Id: Idd270635f70731ccf575174f8f96dc1e95cc0f8a
This commit is contained in:
Boris Pavlovic 2014-01-23 11:36:30 +04:00
parent d41a5cea37
commit a4e906dcfc
15 changed files with 461 additions and 534 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
rally/benchmark/base.py
View File

@ -28,6 +28,12 @@ class Scenario(object):
"""
registred = False
def __init__(self, context=None, admin_clients=None, clients=None):
self._context = context
self._admin_clients = admin_clients
self._clients = clients
self._idle_time = 0
@staticmethod
def register():
if not Scenario.registred:
@ -74,18 +80,16 @@ class Scenario(object):
def cleanup(cls):
"""This method should free all allocated resources."""
@classmethod
def context(cls):
def context(self):
"""Returns the context of the current benchmark scenario.
The context is the return value of the init() class.
:returns: Dict
"""
return cls._context
return self._context
@classmethod
def clients(cls, client_type):
def clients(self, client_type):
"""Returns a python openstack client of the requested type.
The client will be that for one of the temporary non-administrator
@ -95,24 +99,22 @@ class Scenario(object):
:returns: Python openstack client object
"""
return cls._clients[client_type]
return self._clients[client_type]
@classmethod
def admin_clients(cls, client_type):
def admin_clients(self, client_type):
"""Returns a python admin openstack client of the requested type.
:param client_type: Client type ("nova"/"glance" etc.)
:returns: Python openstack client object
"""
return cls._admin_clients[client_type]
return self._admin_clients[client_type]
@classmethod
def sleep_between(cls, min_sleep, max_sleep):
def sleep_between(self, min_sleep, max_sleep):
"""Performs a time.sleep() call for a random amount of seconds.
The exact time is chosen uniformly randomly from the interval
[min_sleep; max_sleep). The method also updates the idle_time class
[min_sleep; max_sleep). The method also updates the idle_time
variable to take into account the overall time spent on sleeping.
:param min_sleep: Minimum sleep time in seconds (non-negative)
@ -124,4 +126,8 @@ class Scenario(object):
sleep_time = random.uniform(min_sleep, max_sleep)
time.sleep(sleep_time)
cls.idle_time += sleep_time
self._idle_time += sleep_time
def idle_time(self):
"""Returns duration of all sleep_between."""
return self._idle_time

16
rally/benchmark/runner.py
View File

@ -42,24 +42,20 @@ def _run_scenario_loop(args):
LOG.info("ITER: %s" % i)
# NOTE(msdubov): Each scenario run uses a random openstack client
# from a predefined set to act from different users.
cls._clients = random.choice(__openstack_clients__)
cls._admin_clients = __admin_clients__
cls._context = __scenario_context__
cls.idle_time = 0
scenario = cls(context=__scenario_context__,
admin_clients=__admin_clients__,
clients=random.choice(__openstack_clients__))
try:
scenario_output = None
with rutils.Timer() as timer:
scenario_output = getattr(cls, method_name)(**kwargs)
scenario_output = getattr(scenario, method_name)(**kwargs)
error = None
except Exception as e:
error = utils.format_exc(e)
finally:
return {"time": timer.duration() - cls.idle_time,
"idle_time": cls.idle_time, "error": error,
return {"time": timer.duration() - scenario.idle_time(),
"idle_time": scenario.idle_time(), "error": error,
"scenario_output": scenario_output}

8
rally/benchmark/scenarios/cinder/utils.py
View File

@ -37,8 +37,7 @@ def generate_volume_name(length=10):
class CinderScenario(base.Scenario):
@classmethod
def _create_volume(cls, size, **kwargs):
def _create_volume(self, size, **kwargs):
"""create one volume.
Returns when the volume is actually created and is in the "Available"
@ -51,7 +50,7 @@ class CinderScenario(base.Scenario):
"""
volumename = kwargs.get('display_name', generate_volume_name(10))
kwargs['display_name'] = volumename
volume = cls.clients("cinder").volumes.create(size, **kwargs)
volume = self.clients("cinder").volumes.create(size, **kwargs)
# NOTE(msdubov): It is reasonable to wait 5 secs before starting to
# check whether the volume is ready => less API calls.
time.sleep(3)
@ -61,8 +60,7 @@ class CinderScenario(base.Scenario):
timeout=600, check_interval=3)
return volume
@classmethod
def _delete_volume(cls, volume):
def _delete_volume(self, volume):
"""Delete the given volume.
Returns when the volume is actually deleted.

26
rally/benchmark/scenarios/cinder/volumes.py
View File

@ -18,15 +18,21 @@ from rally.benchmark.scenarios.cinder import utils
class CinderVolumes(utils.CinderScenario):
@classmethod
def create_and_delete_volume(cls, size,
min_sleep=0, max_sleep=0, **kwargs):
"""Tests creating and then deleting a volume."""
def create_and_delete_volume(self, size, min_sleep=0, max_sleep=0,
**kwargs):
"""Tests creating and then deleting a volume.
volume = cls._create_volume(size, **kwargs)
cls.sleep_between(min_sleep, max_sleep)
cls._delete_volume(volume)
Good for testing a maximal bandwith of cloud.
"""
@classmethod
def create_volume(cls, size, **kwargs):
cls._create_volume(size, **kwargs)
volume = self._create_volume(size, **kwargs)
self.sleep_between(min_sleep, max_sleep)
self._delete_volume(volume)
def create_volume(self, size, **kwargs):
"""Test creating volumes perfromance.
Good test to check how influence amount of active volumes on
performance of creating new.
"""
self._create_volume(size, **kwargs)

12
rally/benchmark/scenarios/keystone/basic.py
View File

@ -18,11 +18,9 @@ from rally.benchmark.scenarios.keystone import utils as kutils
class KeystoneBasic(kutils.KeystoneScenario):
@classmethod
def create_user(cls, name_length=10, **kwargs):
cls._user_create(name_length=name_length, **kwargs)
def create_user(self, name_length=10, **kwargs):
self._user_create(name_length=name_length, **kwargs)
@classmethod
def create_delete_user(cls, name_length=10, **kwargs):
user = cls._user_create(name_length=name_length, **kwargs)
cls._resource_delete(user)
def create_delete_user(self, name_length=10, **kwargs):
user = self._user_create(name_length=name_length, **kwargs)
self._resource_delete(user)

11
rally/benchmark/scenarios/keystone/utils.py
View File

@ -37,8 +37,8 @@ class KeystoneScenario(base.Scenario):
most of them are creating/deleting resources.
"""
@classmethod
def _user_create(cls, name_length=10, password=None, email=None, **kwargs):
def _user_create(self, name_length=10, password=None, email=None,
**kwargs):
"""Creates keystone user with random name.
:param name_length: length of generated (ranodm) part of name
@ -52,10 +52,9 @@ class KeystoneScenario(base.Scenario):
# when we switch to v3.
password = password or name
email = email or (name + "@rally.me")
return cls.admin_clients("keystone").users.create(name, password,
email, **kwargs)
return self.admin_clients("keystone").users.create(name, password,
email, **kwargs)
@classmethod
def _resource_delete(cls, resource):
def _resource_delete(self, resource):
""""Delete keystone resource."""
resource.delete()

142
rally/benchmark/scenarios/nova/servers.py
View File

@ -28,40 +28,37 @@ from rally import sshutils
LOG = logging.getLogger(__name__)
ACTION_BUILDER = scenario_utils.ActionBuilder(
['hard_reboot', 'soft_reboot', 'stop_start', 'rescue_unrescue'])
class NovaServers(utils.NovaScenario,
cinder_utils.CinderScenario):
@classmethod
def boot_and_delete_server(cls, image_id, flavor_id,
def __init__(self, *args, **kwargs):
super(NovaServers, self).__init__(*args, **kwargs)
def boot_and_delete_server(self, image_id, flavor_id,
min_sleep=0, max_sleep=0, **kwargs):
"""Tests booting and then deleting an image."""
server_name = cls._generate_random_name(16)
server_name = self._generate_random_name(16)
server = cls._boot_server(server_name, image_id, flavor_id, **kwargs)
cls.sleep_between(min_sleep, max_sleep)
cls._delete_server(server)
server = self._boot_server(server_name, image_id, flavor_id, **kwargs)
self.sleep_between(min_sleep, max_sleep)
self._delete_server(server)
@classmethod
def boot_server_from_volume_and_delete(cls, image_id, flavor_id,
def boot_server_from_volume_and_delete(self, image_id, flavor_id,
volume_size,
min_sleep=0, max_sleep=0, **kwargs):
"""Tests booting from volume and then deleting an image and volume."""
server_name = cls._generate_random_name(16)
server_name = self._generate_random_name(16)
volume = cls._create_volume(volume_size, imageRef=image_id)
volume = self._create_volume(volume_size, imageRef=image_id)
block_device_mapping = {'vda': '%s:::1' % volume.id}
server = cls._boot_server(server_name, image_id, flavor_id,
block_device_mapping=block_device_mapping,
**kwargs)
cls.sleep_between(min_sleep, max_sleep)
cls._delete_server(server)
server = self._boot_server(server_name, image_id, flavor_id,
block_device_mapping=block_device_mapping,
**kwargs)
self.sleep_between(min_sleep, max_sleep)
self._delete_server(server)
@classmethod
def boot_runcommand_delete_server(cls, image_id, flavor_id,
def boot_runcommand_delete_server(self, image_id, flavor_id,
script, interpreter, network='private',
username='ubuntu', ip_version=4,
retries=60, port=22, **kwargs):
@ -81,10 +78,10 @@ class NovaServers(utils.NovaScenario,
Example Script in doc/samples/support/instance_dd_test.sh
"""
server_name = cls._generate_random_name(16)
server_name = self._generate_random_name(16)
server = cls._boot_server(server_name, image_id, flavor_id,
key_name='rally_ssh_key', **kwargs)
server = self._boot_server(server_name, image_id, flavor_id,
key_name='rally_ssh_key', **kwargs)
if network not in server.addresses:
raise ValueError(
@ -99,7 +96,7 @@ class NovaServers(utils.NovaScenario,
server_ip = [ip for ip in server.addresses[network] if
ip['version'] == ip_version][0]['addr']
ssh = sshutils.SSH(ip=server_ip, port=port, user=username,
key=cls.clients('ssh_key_pair')['private'],
key=self.clients('ssh_key_pair')['private'],
key_type='string')
for retry in range(retries):
@ -123,12 +120,12 @@ class NovaServers(utils.NovaScenario,
'Error: %(error)s') % dict(
id=server.id, ip=server_ip, retry=retry,
error=benchmark_utils.format_exc(e)))
cls.sleep_between(5, 5)
self.sleep_between(5, 5)
except ValueError:
LOG.error(_('Script %(script)s did not output valid JSON. ')
% dict(script=script))
cls._delete_server(server)
self._delete_server(server)
LOG.debug(_('Output streams from in-instance script execution: '
'stdout: %(stdout)s, stderr: $(stderr)s') % dict(
stdout=str(streams[sshutils.SSH.STDOUT_INDEX]),
@ -136,66 +133,76 @@ class NovaServers(utils.NovaScenario,
return dict(data=streams[sshutils.SSH.STDOUT_INDEX],
errors=streams[sshutils.SSH.STDERR_INDEX])
@classmethod
def boot_and_bounce_server(cls, image_id, flavor_id, **kwargs):
def boot_and_bounce_server(self, image_id, flavor_id, **kwargs):
"""Tests booting a server then performing stop/start or hard/soft
reboot a number of times.
"""
action_builder = self._bind_actions()
actions = kwargs.get('actions', [])
try:
ACTION_BUILDER.validate(actions)
action_builder.validate(actions)
except jsonschema.exceptions.ValidationError as error:
raise rally_exceptions.InvalidConfigException(
"Invalid server actions configuration \'%(actions)s\' due to: "
"%(error)s" % {'actions': str(actions), 'error': str(error)})
server = cls._boot_server(cls._generate_random_name(16),
image_id, flavor_id, **kwargs)
for action in ACTION_BUILDER.build_actions(actions, server):
server = self._boot_server(self._generate_random_name(16),
image_id, flavor_id, **kwargs)
for action in action_builder.build_actions(actions, server):
action()
cls._delete_server(server)
self._delete_server(server)
@classmethod
def snapshot_server(cls, image_id, flavor_id, **kwargs):
def snapshot_server(self, image_id, flavor_id, **kwargs):
"""Tests Nova instance snapshotting."""
server_name = cls._generate_random_name(16)
server_name = self._generate_random_name(16)
server = cls._boot_server(server_name, image_id, flavor_id, **kwargs)
image = cls._create_image(server)
cls._delete_server(server)
server = self._boot_server(server_name, image_id, flavor_id, **kwargs)
image = self._create_image(server)
self._delete_server(server)
server = cls._boot_server(server_name, image.id, flavor_id, **kwargs)
cls._delete_server(server)
cls._delete_image(image)
server = self._boot_server(server_name, image.id, flavor_id, **kwargs)
self._delete_server(server)
self._delete_image(image)
@classmethod
def boot_server(cls, image_id, flavor_id, **kwargs):
def boot_server(self, image_id, flavor_id, **kwargs):
"""Test VM boot - assumed clean-up is done elsewhere."""
server_name = cls._generate_random_name(16)
server_name = self._generate_random_name(16)
if 'nics' not in kwargs:
nets = cls.clients("nova").networks.list()
nets = self.clients("nova").networks.list()
if nets:
random_nic = random.choice(nets)
kwargs['nics'] = [{'net-id': random_nic.id}]
cls._boot_server(server_name, image_id, flavor_id, **kwargs)
self._boot_server(server_name, image_id, flavor_id, **kwargs)
@classmethod
def boot_server_from_volume(cls, image_id, flavor_id,
def boot_server_from_volume(self, image_id, flavor_id,
volume_size, **kwargs):
"""Test VM boot from volume - assumed clean-up is done elsewhere."""
server_name = cls._generate_random_name(16)
server_name = self._generate_random_name(16)
if 'nics' not in kwargs:
nets = cls.clients("nova").networks.list()
nets = self.clients("nova").networks.list()
if nets:
random_nic = random.choice(nets)
kwargs['nics'] = [{'net-id': random_nic.id}]
volume = cls._create_volume(volume_size, imageRef=image_id)
volume = self._create_volume(volume_size, imageRef=image_id)
block_device_mapping = {'vda': '%s:::1' % volume.id}
cls._boot_server(server_name, image_id, flavor_id,
block_device_mapping=block_device_mapping,
**kwargs)
self._boot_server(server_name, image_id, flavor_id,
block_device_mapping=block_device_mapping,
**kwargs)
@classmethod
def _stop_and_start_server(cls, server):
def _bind_actions(self):
actions = ['hard_reboot', 'soft_reboot', 'stop_start',
'rescue_unrescue']
action_builder = scenario_utils.ActionBuilder(actions)
action_builder.bind_action('hard_reboot', self._reboot_server,
soft=False)
action_builder.bind_action('soft_reboot', self._reboot_server,
soft=True)
action_builder.bind_action('stop_start',
self._stop_and_start_server)
action_builder.bind_action('rescue_unrescue',
self._rescue_and_unrescue_server)
return action_builder
def _stop_and_start_server(self, server):
"""Stop and then start the given server.
A stop will be issued on the given server upon which time
@ -206,11 +213,10 @@ class NovaServers(utils.NovaScenario,
:param server: The server to stop and then start.
"""
cls._stop_server(server)
cls._start_server(server)
self._stop_server(server)
self._start_server(server)
@classmethod
def _rescue_and_unrescue_server(cls, server):
def _rescue_and_unrescue_server(self, server):
"""Rescue and then unrescue the given server.
A rescue will be issued on the given server upon which time
this method will wait for the server to become 'RESCUE'.
@ -221,15 +227,5 @@ class NovaServers(utils.NovaScenario,
:param server: The server to rescue and then unrescue.
"""
cls._rescue_server(server)
cls._unrescue_server(server)
ACTION_BUILDER.bind_action('hard_reboot',
utils.NovaScenario._reboot_server, soft=False)
ACTION_BUILDER.bind_action('soft_reboot',
utils.NovaScenario._reboot_server, soft=True)
ACTION_BUILDER.bind_action('stop_start',
NovaServers._stop_and_start_server)
ACTION_BUILDER.bind_action('rescue_unrescue',
NovaServers._rescue_and_unrescue_server)
self._rescue_server(server)
self._unrescue_server(server)

70
rally/benchmark/scenarios/nova/utils.py
View File

@ -24,8 +24,7 @@ from rally import utils
class NovaScenario(base.Scenario):
@classmethod
def _boot_server(cls, server_name, image_id, flavor_id, **kwargs):
def _boot_server(self, server_name, image_id, flavor_id, **kwargs):
"""Boots one server.
Returns when the server is actually booted and is in the "Active"
@ -45,8 +44,8 @@ class NovaScenario(base.Scenario):
if 'rally_open' not in kwargs['security_groups']:
kwargs['security_groups'].append('rally_open')
server = cls.clients("nova").servers.create(
server_name, image_id, flavor_id, **kwargs)
server = self.clients("nova").servers.create(server_name, image_id,
flavor_id, **kwargs)
# NOTE(msdubov): It is reasonable to wait 5 secs before starting to
# check whether the server is ready => less API calls.
time.sleep(5)
@ -56,8 +55,7 @@ class NovaScenario(base.Scenario):
timeout=600, check_interval=3)
return server
@classmethod
def _reboot_server(cls, server, soft=True):
def _reboot_server(self, server, soft=True):
"""Reboots the given server using hard or soft reboot.
A reboot will be issued on the given server upon which time
@ -73,8 +71,7 @@ class NovaScenario(base.Scenario):
update_resource=bench_utils.get_from_manager(),
timeout=600, check_interval=3)
@classmethod
def _start_server(cls, server):
def _start_server(self, server):
"""Starts the given server.
A start will be issued for the given server upon which time
@ -87,8 +84,7 @@ class NovaScenario(base.Scenario):
update_resource=bench_utils.get_from_manager(),
timeout=600, check_interval=2)
@classmethod
def _stop_server(cls, server):
def _stop_server(self, server):
"""Stop the given server.
Issues a stop on the given server and waits for the server
@ -101,8 +97,7 @@ class NovaScenario(base.Scenario):
update_resource=bench_utils.get_from_manager(),
timeout=600, check_interval=2)
@classmethod
def _rescue_server(cls, server):
def _rescue_server(self, server):
"""Rescue the given server.
Returns when the server is actually rescue and is in the "Rescue"
@ -116,8 +111,7 @@ class NovaScenario(base.Scenario):
update_resource=bench_utils.get_from_manager(),
timeout=600, check_interval=3)
@classmethod
def _unrescue_server(cls, server):
def _unrescue_server(self, server):
"""Unrescue the given server.
Returns when the server is unrescue and waits to become ACTIVE
@ -130,8 +124,7 @@ class NovaScenario(base.Scenario):
update_resource=bench_utils.get_from_manager(),
timeout=600, check_interval=3)
@classmethod
def _suspend_server(cls, server):
def _suspend_server(self, server):
"""Suspends the given server.
Returns when the server is actually suspended and is in the "Suspended"
@ -145,8 +138,7 @@ class NovaScenario(base.Scenario):
update_resource=bench_utils.get_from_manager(),
timeout=600, check_interval=3)
@classmethod
def _delete_server(cls, server):
def _delete_server(self, server):
"""Deletes the given server.
Returns when the server is actually deleted.
@ -158,15 +150,13 @@ class NovaScenario(base.Scenario):
update_resource=bench_utils.get_from_manager(),
timeout=600, check_interval=3)
@classmethod
def _delete_all_servers(cls):
def _delete_all_servers(self):
"""Deletes all servers in current tenant."""
servers = cls.clients("nova").servers.list()
servers = self.clients("nova").servers.list()
for server in servers:
cls._delete_server(server)
self._delete_server(server)
@classmethod
def _delete_image(cls, image):
def _delete_image(self, image):
"""Deletes the given image.
Returns when the image is actually deleted.
@ -178,8 +168,7 @@ class NovaScenario(base.Scenario):
update_resource=bench_utils.get_from_manager(),
timeout=600, check_interval=3)
@classmethod
def _create_image(cls, server):
def _create_image(self, server):
"""Creates an image of the given server
Uses the server name to name the created image. Returns when the image
@ -189,18 +178,17 @@ class NovaScenario(base.Scenario):
:returns: Created image object
"""
image_uuid = cls.clients("nova").servers.create_image(server,
server.name)
image = cls.clients("nova").images.get(image_uuid)
image_uuid = self.clients("nova").servers.create_image(server,
server.name)
image = self.clients("nova").images.get(image_uuid)
image = utils.wait_for(image,
is_ready=bench_utils.resource_is("ACTIVE"),
update_resource=bench_utils.get_from_manager(),
timeout=600, check_interval=3)
return image
@classmethod
def _boot_servers(cls, name_prefix, image_id, flavor_id,
requests, instances_per_request=1, **kwargs):
def _boot_servers(self, name_prefix, image_id, flavor_id,
requests, instances_amount=1, **kwargs):
"""Boots multiple servers.
Returns when all the servers are actually booted and are in the
@ -211,22 +199,21 @@ class NovaScenario(base.Scenario):
:param image_id: ID of the image to be used for server creation
:param flavor_id: ID of the flavor to be used for server creation
:param requests: Number of booting requests to perform
:param instances_per_request: Number of instances to boot
per each request
:param instances_amount: Number of instances to boot per each request
:returns: List of created server objects
"""
for i in range(requests):
cls.clients("nova").servers.create('%s_%d' % (name_prefix, i),
image_id, flavor_id,
min_count=instances_per_request,
max_count=instances_per_request,
**kwargs)
self.clients("nova").servers.create('%s_%d' % (name_prefix, i),
image_id, flavor_id,
min_count=instances_amount,
max_count=instances_amount,
**kwargs)
# NOTE(msdubov): Nova python client returns only one server even when
# min_count > 1, so we have to rediscover all the
# created servers manyally.
servers = filter(lambda server: server.name.startswith(name_prefix),
cls.clients("nova").servers.list())
self.clients("nova").servers.list())
time.sleep(5)
servers = [utils.wait_for(server,
is_ready=bench_utils.resource_is("ACTIVE"),
@ -236,6 +223,5 @@ class NovaScenario(base.Scenario):
for server in servers]
return servers
@classmethod
def _generate_random_name(cls, length):
def _generate_random_name(self, length):
return ''.join(random.choice(string.lowercase) for i in range(length))

35
tests/benchmark/scenarios/cinder/test_volumes.py
View File

@ -24,19 +24,24 @@ CINDER_VOLUMES = "rally.benchmark.scenarios.cinder.volumes.CinderVolumes"
class CinderServersTestCase(test.TestCase):
@mock.patch(CINDER_VOLUMES + ".sleep_between")
@mock.patch(CINDER_VOLUMES + "._delete_volume")
@mock.patch(CINDER_VOLUMES + "._create_volume")
def _verify_create_and_delete_volume(self, mock_create, mock_delete,
mock_sleep):
fake_volume = object()
mock_create.return_value = fake_volume
volumes.CinderVolumes.create_and_delete_volume(1, 10, 20,
fakearg="f")
mock_create.assert_called_once_with(1, fakearg="f")
mock_sleep.assert_called_once_with(10, 20)
mock_delete.assert_called_once_with(fake_volume)
def test_create_and_delete_volume(self):
self._verify_create_and_delete_volume()
fake_volume = mock.MagicMock()
scenario = volumes.CinderVolumes()
scenario._create_volume = mock.MagicMock(return_value=fake_volume)
scenario.sleep_between = mock.MagicMock()
scenario._delete_volume = mock.MagicMock()
scenario.create_and_delete_volume(1, 10, 20, fakearg="f")
scenario._create_volume.assert_called_once_with(1, fakearg="f")
scenario.sleep_between.assert_called_once_with(10, 20)
scenario._delete_volume.assert_called_once_with(fake_volume)
def test_create_volume(self):
fake_volume = mock.MagicMock()
scenario = volumes.CinderVolumes()
scenario._create_volume = mock.MagicMock(return_value=fake_volume)
scenario.create_volume(1, fakearg="f")
scenario._create_volume.assert_called_once_with(1, fakearg="f")

37
tests/benchmark/scenarios/keystone/test_basic.py
View File

@ -27,26 +27,29 @@ KEYSTONE_UTILS = KEYSTONE_BASE + "utils."
class KeystoneBasicTestCase(test.TestCase):
@mock.patch(KEYSTONE_UTILS + "generate_keystone_name")
@mock.patch(KEYSTONE_BASIC + "_user_create")
def test_create_user(self, mock_create, mock_gen_name):
def test_create_user(self, mock_gen_name):
scenario = basic.KeystoneBasic()
mock_gen_name.return_value = "teeeest"
basic.KeystoneBasic.create_user(name_length=20, password="tttt",
**{"tenant_id": "id"})
mock_create.assert_called_once_with(name_length=20, password="tttt",
**{"tenant_id": "id"})
scenario._user_create = mock.MagicMock()
scenario.create_user(name_length=20, password="tttt",
**{"tenant_id": "id"})
scenario._user_create.assert_called_once_with(name_length=20,
password="tttt",
**{"tenant_id": "id"})
@mock.patch(KEYSTONE_UTILS + "generate_keystone_name")
@mock.patch(KEYSTONE_BASIC + "_resource_delete")
@mock.patch(KEYSTONE_BASIC + "_user_create")
def test_create_delete_user(self, mock_create, mock_delete, mock_gen_name):
create_result = {}
mock_create.return_value = create_result
def test_create_delete_user(self, mock_gen_name):
create_result = mock.MagicMock()
scenario = basic.KeystoneBasic()
scenario._user_create = mock.MagicMock(return_value=create_result)
scenario._resource_delete = mock.MagicMock()
mock_gen_name.return_value = "teeeest"
basic.KeystoneBasic.create_delete_user(name_length=30, email="abcd",
**{"enabled": True})
scenario.create_delete_user(name_length=30, email="abcd",
**{"enabled": True})
mock_create.assert_called_once_with(name_length=30, email="abcd",
**{"enabled": True})
mock_delete.assert_called_once_with(create_result)
scenario._user_create.assert_called_once_with(name_length=30,
email="abcd",
**{"enabled": True})
scenario._resource_delete.assert_called_once_with(create_result)

11
tests/benchmark/scenarios/keystone/test_utils.py
View File

@ -47,21 +47,20 @@ class KeystoneUtilsTestCase(test.TestCase):
class KeystoneScenarioTestCase(test.TestCase):
@mock.patch(UTILS + "KeystoneScenario.admin_clients")
@mock.patch(UTILS + "generate_keystone_name")
def test_user_create(self, mock_gen_name, mock_admin_clients):
def test_user_create(self, mock_gen_name):
name = "abc"
mock_gen_name.return_value = name
user = {}
fake_keystone = fakes.FakeKeystoneClient()
fake_keystone.users.create = mock.MagicMock(return_value=user)
mock_admin_clients.return_value = fake_keystone
scenario = utils.KeystoneScenario(
admin_clients={"keystone": fake_keystone})
result = utils.KeystoneScenario._user_create()
result = scenario._user_create()
self.assertEqual(user, result)
mock_admin_clients.assert_called_once_with("keystone")
fake_keystone.users.create.assert_called_once_with(name, name,
name + "@rally.me")
@ -69,5 +68,5 @@ class KeystoneScenarioTestCase(test.TestCase):
resource = fakes.FakeResource()
resource.delete = mock.MagicMock()
utils.KeystoneScenario._resource_delete(resource)
utils.KeystoneScenario()._resource_delete(resource)
resource.delete.assert_called_once_with()

470
tests/benchmark/scenarios/nova/test_servers.py
View File

@ -27,60 +27,12 @@ NOVA_SERVERS = "rally.benchmark.scenarios.nova.servers.NovaServers"
class NovaServersTestCase(test.TestCase):
@mock.patch(NOVA_SERVERS + ".sleep_between")
@mock.patch(NOVA_SERVERS + "._generate_random_name")
@mock.patch(NOVA_SERVERS + "._delete_server")
@mock.patch(NOVA_SERVERS + "._boot_server")
def _verify_boot_and_delete_server(self, mock_boot, mock_delete,
mock_random_name, mock_sleep):
fake_server = object()
mock_boot.return_value = fake_server
mock_random_name.return_value = "random_name"
servers.NovaServers.boot_and_delete_server("img", 0, 10, 20,
fakearg="f")
mock_boot.assert_called_once_with("random_name", "img", 0, fakearg="f")
mock_sleep.assert_called_once_with(10, 20)
mock_delete.assert_called_once_with(fake_server)
@mock.patch(NOVA_SERVERS + ".sleep_between")
@mock.patch(NOVA_SERVERS + "._generate_random_name")
@mock.patch(NOVA_SERVERS + "._delete_server")
@mock.patch(NOVA_SERVERS + "._boot_server")
@mock.patch(NOVA_SERVERS + "._create_volume")
def _verify_boot_server_from_volume_and_delete(self, mock_volume,
mock_boot, mock_delete,
mock_random_name,
mock_sleep):
fake_server = object()
mock_boot.return_value = fake_server
mock_random_name.return_value = "random_name"
fake_volume = fakes.FakeVolumeManager().create()
fake_volume.id = "volume_id"
mock_volume.return_value = fake_volume
servers.NovaServers.boot_server_from_volume_and_delete("img", 0, 5,
10, 20,
fakearg="f")
mock_volume.assert_called_once_with(5, imageRef="img")
mock_boot.assert_called_once_with(
"random_name", "img", 0,
block_device_mapping={'vda': 'volume_id:::1'},
fakearg="f")
mock_sleep.assert_called_once_with(10, 20)
mock_delete.assert_called_once_with(fake_server)
@mock.patch("json.loads")
@mock.patch("rally.benchmark.base.Scenario.clients")
@mock.patch("rally.sshutils.SSH.execute_script")
@mock.patch(NOVA_SERVERS + ".sleep_between")
@mock.patch(NOVA_SERVERS + "._generate_random_name")
@mock.patch(NOVA_SERVERS + "._delete_server")
@mock.patch(NOVA_SERVERS + "._boot_server")
def _verify_boot_runcommand_delete_server(
self, mock_boot, mock_delete, mock_random_name, mock_sleep,
mock_ssh_execute_script, mock_base_clients, mock_json_loads):
def _verify_boot_runcommand_delete_server(self, mock_ssh_execute_script,
mock_base_clients,
mock_json_loads):
fake_server = fakes.FakeServer()
fake_server.addresses = dict(
private=[dict(
@ -88,243 +40,158 @@ class NovaServersTestCase(test.TestCase):
addr="1.2.3.4"
)]
)
mock_boot.return_value = fake_server
mock_random_name.return_value = "random_name"
scenario = servers.NovaServers()
scenario._boot_server = mock.MagicMock(return_value=fake_server)
scenario._generate_random_name = mock.MagicMock(return_value="name")
scenario._delete_server = mock.MagicMock()
mock_ssh_execute_script.return_value = ('stdout', 'stderr')
mock_base_clients.return_value = dict(private='private-key-string')
servers.NovaServers.boot_runcommand_delete_server(
"img", 0, "script_path", "/bin/bash", fakearg="f")
scenario.boot_runcommand_delete_server("img", 0, "script_path",
"/bin/bash", fakearg="f")
mock_boot.assert_called_once_with(
"random_name", "img", 0, fakearg="f", key_name='rally_ssh_key')
scenario._boot_server.assert_called_once_with("name", "img", 0,
fakearg="f",
key_name='rally_ssh_key')
mock_ssh_execute_script.assert_called_once_with(
script="script_path",
interpreter="/bin/bash",
get_stdout=True,
get_stderr=True
)
script="script_path", interpreter="/bin/bash", get_stdout=True,
get_stderr=True)
mock_json_loads.assert_called_once_with('stdout')
mock_delete.assert_called_once_with(fake_server)
scenario._delete_server.assert_called_once_with(fake_server)
fake_server.addresses = {}
self.assertRaises(
ValueError,
servers.NovaServers.boot_runcommand_delete_server,
scenario.boot_runcommand_delete_server,
"img", 0, "script_path", "/bin/bash",
fakearg="f"
)
@mock.patch(NOVA_SERVERS + "._generate_random_name")
@mock.patch(NOVA_SERVERS + "._boot_server")
@mock.patch("rally.benchmark.utils.osclients")
@mock.patch("rally.benchmark.scenarios.nova.servers.random.choice")
def _verify_boot_server(self, mock_choice, mock_osclients, mock_boot,
mock_random_name, nic=None, assert_nic=False):
assert_nic = nic or assert_nic
kwargs = {'fakearg': 'f'}
expected_kwargs = {'fakearg': 'f'}
fc = fakes.FakeClients()
mock_osclients.Clients.return_value = fc
nova = fakes.FakeNovaClient()
fc.get_nova_client = lambda: nova
temp_keys = ["username", "password", "tenant_name", "auth_url"]
users_endpoints = [dict(zip(temp_keys, temp_keys))]
servers.NovaServers._clients = butils.create_openstack_clients(
users_endpoints, temp_keys)[0]
mock_boot.return_value = object()
mock_random_name.return_value = "random_name"
if nic:
kwargs['nics'] = nic
if assert_nic:
nova.networks.create('net-1')
network = nova.networks.create('net-2')
mock_choice.return_value = network
expected_kwargs['nics'] = nic or [{'net-id': 'net-2'}]
servers.NovaServers.boot_server("img", 0, **kwargs)
mock_boot.assert_called_once_with("random_name", "img", 0,
**expected_kwargs)
@mock.patch(NOVA_SERVERS + "._generate_random_name")
@mock.patch(NOVA_SERVERS + "._boot_server")
@mock.patch("rally.benchmark.utils.osclients")
@mock.patch("rally.benchmark.scenarios.nova.servers.random.choice")
@mock.patch(NOVA_SERVERS + "._create_volume")
def _verify_boot_server_from_volume(self, mock_volume, mock_choice,
mock_osclients, mock_boot,
mock_random_name, nic=None,
assert_nic=False):
assert_nic = nic or assert_nic
kwargs = {'fakearg': 'f'}
expected_kwargs = {'fakearg': 'f'}
fc = fakes.FakeClients()
mock_osclients.Clients.return_value = fc
nova = fakes.FakeNovaClient()
fc.get_nova_client = lambda: nova
temp_keys = ["username", "password", "tenant_name", "uri"]
users_endpoints = [dict(zip(temp_keys, temp_keys))]
servers.NovaServers._clients = butils.create_openstack_clients(
users_endpoints, temp_keys)[0]
mock_boot.return_value = object()
mock_random_name.return_value = "random_name"
if nic:
kwargs['nics'] = nic
if assert_nic:
nova.networks.create('net-1')
network = nova.networks.create('net-2')
mock_choice.return_value = network
expected_kwargs['nics'] = nic or [{'net-id': 'net-2'}]
fake_volume = fakes.FakeVolumeManager().create()
fake_volume.id = "volume_id"
mock_volume.return_value = fake_volume
servers.NovaServers.boot_server_from_volume("img", 0, 5, **kwargs)
mock_volume.assert_called_once_with(5, imageRef="img")
mock_boot.assert_called_once_with(
"random_name", "img", 0,
block_device_mapping={'vda': 'volume_id:::1'},
**expected_kwargs)
@mock.patch(NOVA_SERVERS + "._generate_random_name")
@mock.patch(NOVA_SERVERS + "._delete_server")
@mock.patch(NOVA_SERVERS + "._rescue_server")
@mock.patch(NOVA_SERVERS + "._unrescue_server")
@mock.patch(NOVA_SERVERS + "._boot_server")
def test_boot_rescue_unrescue(self, mock_boot, mock_unrescue,
mock_rescue, mock_delete, mock_name):
def test_boot_rescue_unrescue(self):
actions = [{'rescue_unrescue': 5}]
fake_server = object()
mock_boot.return_value = fake_server
mock_name.return_value = 'random_name'
servers.NovaServers.boot_and_bounce_server("img", 1,
actions=actions)
mock_boot.assert_called_once_with("random_name", "img", 1,
actions=actions)
fake_server = mock.MagicMock()
scenario = servers.NovaServers()
scenario._boot_server = mock.MagicMock(return_value=fake_server)
scenario._generate_random_name = mock.MagicMock(return_value="name")
scenario._rescue_server = mock.MagicMock()
scenario._unrescue_server = mock.MagicMock()
scenario._delete_server = mock.MagicMock()
scenario.boot_and_bounce_server("img", 1, actions=actions)
scenario._boot_server.assert_called_once_with("name", "img", 1,
actions=actions)
server_calls = []
for i in range(5):
server_calls.append(mock.call(fake_server))
self.assertEqual(5, mock_rescue.call_count,
self.assertEqual(5, scenario._rescue_server.call_count,
"Rescue not called 5 times")
self.assertEqual(5, mock_unrescue.call_count,
self.assertEqual(5, scenario._unrescue_server.call_count,
"Unrescue not called 5 times")
mock_rescue.assert_has_calls(server_calls)
mock_unrescue.assert_has_calls(server_calls)
mock_delete.assert_called_once_with(fake_server)
scenario._rescue_server.assert_has_calls(server_calls)
scenario._unrescue_server.assert_has_calls(server_calls)
scenario._delete_server.assert_called_once_with(fake_server)
@mock.patch(NOVA_SERVERS + "._generate_random_name")
@mock.patch(NOVA_SERVERS + "._delete_server")
@mock.patch(NOVA_SERVERS + "._stop_server")
@mock.patch(NOVA_SERVERS + "._start_server")
@mock.patch(NOVA_SERVERS + "._boot_server")
def test_boot_stop_start(self, mock_boot, mock_start, mock_stop,
mock_delete, mock_name):
def test_boot_stop_start(self):
actions = [{'stop_start': 5}]
fake_server = object()
mock_boot.return_value = fake_server
mock_name.return_value = 'random_name'
servers.NovaServers.boot_and_bounce_server("img", 1,
actions=actions)
mock_boot.assert_called_once_with("random_name", "img", 1,
actions=actions)
fake_server = mock.MagicMock()
scenario = servers.NovaServers()
scenario._boot_server = mock.MagicMock(return_value=fake_server)
scenario._generate_random_name = mock.MagicMock(return_value="name")
scenario._start_server = mock.MagicMock()
scenario._stop_server = mock.MagicMock()
scenario._delete_server = mock.MagicMock()
scenario.boot_and_bounce_server("img", 1, actions=actions)
scenario._boot_server.assert_called_once_with("name", "img", 1,
actions=actions)
server_calls = []
for i in range(5):
server_calls.append(mock.call(fake_server))
self.assertEqual(5, mock_stop.call_count, "Stop not called 5 times")
self.assertEqual(5, mock_start.call_count, "Start not called 5 times")
mock_stop.assert_has_calls(server_calls)
mock_start.assert_has_calls(server_calls)
mock_delete.assert_called_once_with(fake_server)
self.assertEqual(5, scenario._stop_server.call_count,
"Stop not called 5 times")
self.assertEqual(5, scenario._start_server.call_count,
"Start not called 5 times")
scenario._stop_server.assert_has_calls(server_calls)
scenario._start_server.assert_has_calls(server_calls)
scenario._delete_server.assert_called_once_with(fake_server)
def _bind_server_actions(self, mock_reboot, mock_stop_start):
bindings = servers.ACTION_BUILDER._bindings
if mock_reboot:
bindings['soft_reboot']['action'] = mock_reboot
bindings['hard_reboot']['action'] = mock_reboot
if mock_stop_start:
bindings['stop_start']['action'] = mock_stop_start
@mock.patch(NOVA_SERVERS + "._generate_random_name")
@mock.patch(NOVA_SERVERS + "._delete_server")
@mock.patch(NOVA_SERVERS + "._reboot_server")
@mock.patch(NOVA_SERVERS + "._boot_server")
def _verify_reboot(self, mock_boot, mock_reboot, mock_delete, mock_name,
soft=True):
actions = [{'soft_reboot' if soft else 'hard_reboot': 5}]
fake_server = object()
self._bind_server_actions(mock_reboot, None)
mock_boot.return_value = fake_server
mock_name.return_value = 'random_name'
servers.NovaServers.boot_and_bounce_server("img", 1,
actions=actions)
mock_boot.assert_called_once_with("random_name", "img", 1,
actions=actions)
server_calls = []
for i in range(5):
server_calls.append(mock.call(fake_server, soft=soft))
self.assertEqual(5, mock_reboot.call_count,
"Reboot not called 5 times")
mock_reboot.assert_has_calls(server_calls)
mock_delete.assert_called_once_with(fake_server)
@mock.patch(NOVA_SERVERS + "._generate_random_name")
@mock.patch(NOVA_SERVERS + "._delete_server")
@mock.patch(NOVA_SERVERS + "._stop_and_start_server")
@mock.patch(NOVA_SERVERS + "._reboot_server")
@mock.patch(NOVA_SERVERS + "._boot_server")
def test_multiple_bounce_actions(self, mock_boot, mock_reboot,
mock_stop_start, mock_delete, mock_name):
def test_multiple_bounce_actions(self):
actions = [{'hard_reboot': 5}, {'stop_start': 8}]
fake_server = object()
self._bind_server_actions(mock_reboot, mock_stop_start)
mock_boot.return_value = fake_server
mock_name.return_value = 'random_name'
servers.NovaServers.boot_and_bounce_server("img", 1,
actions=actions)
mock_boot.assert_called_once_with("random_name", "img", 1,
actions=actions)
fake_server = mock.MagicMock()
scenario = servers.NovaServers()
scenario._boot_server = mock.MagicMock(return_value=fake_server)
scenario._delete_server = mock.MagicMock()
scenario._reboot_server = mock.MagicMock()
scenario._stop_and_start_server = mock.MagicMock()
scenario._generate_random_name = mock.MagicMock(return_value='name')
scenario.boot_and_bounce_server("img", 1, actions=actions)
scenario._boot_server.assert_called_once_with("name", "img", 1,
actions=actions)
server_calls = []
for i in range(5):
server_calls.append(mock.call(fake_server, soft=False))
self.assertEqual(5, mock_reboot.call_count,
self.assertEqual(5, scenario._reboot_server.call_count,
"Reboot not called 5 times")
mock_reboot.assert_has_calls(server_calls)
scenario._reboot_server.assert_has_calls(server_calls)
server_calls = []
for i in range(8):
server_calls.append(mock.call(fake_server))
self.assertEqual(8, mock_stop_start.call_count,
self.assertEqual(8, scenario._stop_and_start_server.call_count,
"Stop/Start not called 8 times")
mock_stop_start.assert_has_calls(server_calls)
mock_delete.assert_called_once_with(fake_server)
scenario._stop_and_start_server.assert_has_calls(server_calls)
scenario._delete_server.assert_called_once_with(fake_server)
def test_validate_actions(self):
actions = [{"hardd_reboot": 6}]
scenario = servers.NovaServers()
self.assertRaises(rally_exceptions.InvalidConfigException,
servers.NovaServers.boot_and_bounce_server,
scenario.boot_and_bounce_server,
1, 1, actions=actions)
actions = [{"hard_reboot": "no"}]
self.assertRaises(rally_exceptions.InvalidConfigException,
servers.NovaServers.boot_and_bounce_server,
scenario.boot_and_bounce_server,
1, 1, actions=actions)
actions = {"hard_reboot": 6}
self.assertRaises(rally_exceptions.InvalidConfigException,
servers.NovaServers.boot_and_bounce_server,
scenario.boot_and_bounce_server,
1, 1, actions=actions)
actions = {"hard_reboot": -1}
self.assertRaises(rally_exceptions.InvalidConfigException,
servers.NovaServers.boot_and_bounce_server,
scenario.boot_and_bounce_server,
1, 1, actions=actions)
actions = {"hard_reboot": 0}
self.assertRaises(rally_exceptions.InvalidConfigException,
servers.NovaServers.boot_and_bounce_server,
scenario.boot_and_bounce_server,
1, 1, actions=actions)
def _verify_reboot(self, soft=True):
actions = [{'soft_reboot' if soft else 'hard_reboot': 5}]
fake_server = mock.MagicMock()
scenario = servers.NovaServers()
scenario._reboot_server = mock.MagicMock()
scenario._boot_server = mock.MagicMock(return_value=fake_server)
scenario._delete_server = mock.MagicMock()
scenario._generate_random_name = mock.MagicMock(return_value='name')
scenario.boot_and_bounce_server("img", 1, actions=actions)
scenario._boot_server.assert_called_once_with("name", "img", 1,
actions=actions)
server_calls = []
for i in range(5):
server_calls.append(mock.call(fake_server, soft=soft))
self.assertEqual(5, scenario._reboot_server.call_count,
"Reboot not called 5 times")
scenario._reboot_server.assert_has_calls(server_calls)
scenario._delete_server.assert_called_once_with(fake_server)
def test_boot_soft_reboot(self):
self._verify_reboot(soft=True)
@ -332,10 +199,88 @@ class NovaServersTestCase(test.TestCase):
self._verify_reboot(soft=False)
def test_boot_and_delete_server(self):
self._verify_boot_and_delete_server()
fake_server = object()
scenario = servers.NovaServers()
scenario._generate_random_name = mock.MagicMock(return_value="name")
scenario._boot_server = mock.MagicMock(return_value=fake_server)
scenario._delete_server = mock.MagicMock()
scenario.sleep_between = mock.MagicMock()
scenario.boot_and_delete_server("img", 0, 10, 20, fakearg="fakearg")
scenario._boot_server.assert_called_once_with("name", "img", 0,
fakearg="fakearg")
scenario.sleep_between.assert_called_once_with(10, 20)
scenario._delete_server.assert_called_once_with(fake_server)
def test_boot_server_from_volume_and_delete(self):
self._verify_boot_server_from_volume_and_delete()
fake_server = object()
scenario = servers.NovaServers()
scenario._boot_server = mock.MagicMock(return_value=fake_server)
scenario._generate_random_name = mock.MagicMock(return_value="name")
scenario.sleep_between = mock.MagicMock()
scenario._delete_server = mock.MagicMock()
fake_volume = fakes.FakeVolumeManager().create()
fake_volume.id = "volume_id"
scenario._create_volume = mock.MagicMock(return_value=fake_volume)
scenario.boot_server_from_volume_and_delete("img", 0, 5, 10, 20,
fakearg="f")
scenario._create_volume.assert_called_once_with(5, imageRef="img")
scenario._boot_server.assert_called_once_with(
"name", "img", 0,
block_device_mapping={'vda': 'volume_id:::1'},
fakearg="f")
scenario.sleep_between.assert_called_once_with(10, 20)
scenario._delete_server.assert_called_once_with(fake_server)
@mock.patch("rally.benchmark.utils.osclients")
def _prepare_boot(self, mock_osclients, mock_choice=None, nic=None,
assert_nic=False):
fake_server = mock.MagicMock()
fc = fakes.FakeClients()
mock_osclients.Clients.return_value = fc
nova = fakes.FakeNovaClient()
fc.get_nova_client = lambda: nova
temp_keys = ["username", "password", "tenant_name", "auth_url"]
users_endpoints = [dict(zip(temp_keys, temp_keys))]
clients = butils.create_openstack_clients(users_endpoints,
temp_keys)[0]
scenario = servers.NovaServers(clients=clients)
scenario._boot_server = mock.MagicMock(return_value=fake_server)
scenario._generate_random_name = mock.MagicMock(return_value="name")
kwargs = {'fakearg': 'f'}
expected_kwargs = {'fakearg': 'f'}
assert_nic = nic or assert_nic
if nic:
kwargs['nics'] = nic
if assert_nic:
nova.networks.create('net-1')
mock_choice.return_value = nova.networks.create('net-2')
expected_kwargs['nics'] = nic or [{'net-id': 'net-2'}]
print(kwargs)
print(expected_kwargs)
return scenario, kwargs, expected_kwargs
@mock.patch("rally.benchmark.scenarios.nova.servers.random.choice")
def _verify_boot_server(self, mock_choice, nic=None, assert_nic=False):
scenario, kwargs, expected_kwargs = \
self._prepare_boot(mock_choice=mock_choice,
nic=nic, assert_nic=assert_nic)
scenario.boot_server("img", 0, **kwargs)
scenario._boot_server.assert_called_once_with("name", "img", 0,
**expected_kwargs)
def test_boot_runcommand_delete_server(self):
self._verify_boot_runcommand_delete_server()
@ -350,32 +295,43 @@ class NovaServersTestCase(test.TestCase):
def test_boot_server_random_nic(self):
self._verify_boot_server(nic=None, assert_nic=True)
def test_boot_server_from_volume_random_nic(self):
self._verify_boot_server_from_volume(nic=None, assert_nic=True)
@mock.patch("rally.benchmark.scenarios.nova.servers.random.choice")
def test_boot_server_from_volume_random_nic(self, mock_choice):
scenario, kwargs, expected_kwargs = \
self._prepare_boot(mock_choice=mock_choice, nic=None,
assert_nic=True)
@mock.patch(NOVA_SERVERS + "._generate_random_name")
@mock.patch(NOVA_SERVERS + "._delete_image")
@mock.patch(NOVA_SERVERS + "._delete_server")
@mock.patch(NOVA_SERVERS + "._create_image")
@mock.patch(NOVA_SERVERS + "._boot_server")
def test_snapshot_server(self, mock_boot, mock_create_image,
mock_delete_server, mock_delete_image,
mock_random_name):
fake_volume = fakes.FakeVolumeManager().create()
fake_volume.id = "volume_id"
scenario._create_volume = mock.MagicMock(return_value=fake_volume)
scenario.boot_server_from_volume("img", 0, 5, **kwargs)
scenario._create_volume.assert_called_once_with(5, imageRef="img")
scenario._boot_server.assert_called_once_with(
"name", "img", 0,
block_device_mapping={"vda": "volume_id:::1"},
**expected_kwargs)
def test_snapshot_server(self):
fake_server = object()
fake_image = fakes.FakeImageManager().create()
fake_image.id = "image_id"
mock_random_name.return_value = "random_name"
mock_boot.return_value = fake_server
mock_create_image.return_value = fake_image
servers.NovaServers.snapshot_server("i", 0, fakearg=2)
scenario = servers.NovaServers()
scenario._generate_random_name = mock.MagicMock(return_value="name")
scenario._boot_server = mock.MagicMock(return_value=fake_server)
scenario._create_image = mock.MagicMock(return_value=fake_image)
scenario._delete_server = mock.MagicMock()
scenario._delete_image = mock.MagicMock()
mock_boot.assert_has_calls([
mock.call("random_name", "i", 0, fakearg=2),
mock.call("random_name", "image_id", 0, fakearg=2)])
mock_create_image.assert_called_once_with(fake_server)
mock_delete_server.assert_has_calls([
scenario.snapshot_server("i", 0, fakearg=2)
scenario._boot_server.assert_has_calls([
mock.call("name", "i", 0, fakearg=2),
mock.call("name", "image_id", 0, fakearg=2)])
scenario._create_image.assert_called_once_with(fake_server)
scenario._delete_server.assert_has_calls([
mock.call(fake_server),
mock.call(fake_server)])
mock_delete_image.assert_called_once_with(fake_image)
scenario._delete_image.assert_called_once_with(fake_image)

33
tests/benchmark/scenarios/nova/test_utils.py
View File

@ -44,7 +44,7 @@ class NovaScenarioTestCase(test.TestCase):
def test_generate_random_name(self):
for length in [8, 16, 32, 64]:
name = utils.NovaScenario._generate_random_name(length)
name = utils.NovaScenario()._generate_random_name(length)
self.assertEqual(len(name), length)
self.assertTrue(name.isalpha())
@ -77,15 +77,18 @@ class NovaScenarioTestCase(test.TestCase):
fsm.create_image = lambda svr, name: fake_image.id
temp_keys = ["username", "password", "tenant_name", "auth_url"]
users_endpoints = [dict(zip(temp_keys, temp_keys))]
utils.NovaScenario._clients = butils.\
create_openstack_clients(users_endpoints, temp_keys)[0]
tmp_clients = butils.create_openstack_clients(users_endpoints,
temp_keys)[0]
novascenario = utils.NovaScenario(clients=tmp_clients)
utils.utils = mock_rally_utils
utils.bench_utils.get_from_manager = lambda: get_from_mgr
utils.NovaScenario._boot_server("s1", "i1", 1)
utils.NovaScenario._create_image(fake_server)
utils.NovaScenario._suspend_server(fake_server)
utils.NovaScenario._delete_server(fake_server)
novascenario._boot_server("s1", "i1", 1)
novascenario._create_image(fake_server)
novascenario._suspend_server(fake_server)
novascenario._delete_server(fake_server)
expected = [
mock.call.wait_for(fake_server, is_ready=_is_ready,
@ -105,7 +108,7 @@ class NovaScenarioTestCase(test.TestCase):
self.assertEqual(expected, mock_rally_utils.mock_calls)
def test_server_reboot(self):
utils.NovaScenario._reboot_server(self.server)
utils.NovaScenario()._reboot_server(self.server)
self.server.reboot.assert_called_once_with(reboot_type='SOFT')
self.wait_for.mock.assert_called_once_with(self.server,
update_resource=self.gfm(),
@ -115,7 +118,7 @@ class NovaScenarioTestCase(test.TestCase):
self.res_is.mock.assert_has_calls(mock.call('ACTIVE'))
def test_server_start(self):
utils.NovaScenario._start_server(self.server)
utils.NovaScenario()._start_server(self.server)
self.server.start.assert_called_once_with()
self.wait_for.mock.assert_called_once_with(self.server,
update_resource=self.gfm(),
@ -125,7 +128,7 @@ class NovaScenarioTestCase(test.TestCase):
self.res_is.mock.assert_has_calls(mock.call('ACTIVE'))
def test_server_stop(self):
utils.NovaScenario._stop_server(self.server)
utils.NovaScenario()._stop_server(self.server)
self.server.stop.assert_called_once_with()
self.wait_for.mock.assert_called_once_with(self.server,
update_resource=self.gfm(),
@ -135,7 +138,7 @@ class NovaScenarioTestCase(test.TestCase):
self.res_is.mock.assert_has_calls(mock.call('SHUTOFF'))
def test_server_rescue(self):
utils.NovaScenario._rescue_server(self.server)
utils.NovaScenario()._rescue_server(self.server)
self.server.rescue.assert_called_once_with()
self.wait_for.mock.assert_called_once_with(self.server,
update_resource=self.gfm(),
@ -145,7 +148,7 @@ class NovaScenarioTestCase(test.TestCase):
self.res_is.mock.assert_has_calls(mock.call('RESCUE'))
def test_server_unrescue(self):
utils.NovaScenario._unrescue_server(self.server)
utils.NovaScenario()._unrescue_server(self.server)
self.server.unrescue.assert_called_once_with()
self.wait_for.mock.assert_called_once_with(self.server,
update_resource=self.gfm(),
@ -159,7 +162,7 @@ class NovaScenarioTestCase(test.TestCase):
def test_delete_all_servers(self, mock_clients, mock_isnone):
mock_clients("nova").servers.list.return_value = [self.server,
self.server1]
utils.NovaScenario._delete_all_servers()
utils.NovaScenario()._delete_all_servers()
expected = [
mock.call(self.server, is_ready=mock_isnone,
update_resource=self.gfm(),
@ -171,7 +174,7 @@ class NovaScenarioTestCase(test.TestCase):
self.assertEqual(expected, self.wait_for.mock.mock_calls)
def test_delete_image(self):
utils.NovaScenario._delete_image(self.image)
utils.NovaScenario()._delete_image(self.image)
self.image.delete.assert_called_once_with()
self.wait_for.mock.assert_called_once_with(self.image,
update_resource=self.gfm(),
@ -184,7 +187,7 @@ class NovaScenarioTestCase(test.TestCase):
def test_boot_servers(self, mock_clients):
mock_clients("nova").servers.list.return_value = [self.server,
self.server1]
utils.NovaScenario._boot_servers('prefix', 'image', 'flavor', 2)
utils.NovaScenario()._boot_servers('prefix', 'image', 'flavor', 2)
expected = [
mock.call(self.server, is_ready=self.res_is.mock(),
update_resource=self.gfm(),

76
tests/benchmark/test_base.py
View File

@ -54,65 +54,47 @@ class ScenarioTestCase(test.TestCase):
def test_cleanup(self):
base.Scenario.cleanup()
def test_sleep_between(self):
base.Scenario.idle_time = 0
with mock.patch("rally.benchmark.base.random.uniform") as mock_uniform:
mock_uniform.return_value = 10
with mock.patch("rally.benchmark.base.time.sleep") as mock_sleep:
base.Scenario.sleep_between(5, 15)
base.Scenario.sleep_between(10, 10)
expected = [
mock.call(5, 15),
mock.call(10, 10),
]
@mock.patch("rally.benchmark.base.time.sleep")
@mock.patch("rally.benchmark.base.random.uniform")
def test_sleep_between(self, mock_uniform, mock_sleep):
scenario = base.Scenario()
mock_uniform.return_value = 10
scenario.sleep_between(5, 15)
scenario.sleep_between(10, 10)
expected = [mock.call(5, 15), mock.call(10, 10)]
self.assertEqual(mock_uniform.mock_calls, expected)
expected = [
mock.call(10),
mock.call(10)
]
expected = [mock.call(10), mock.call(10)]
self.assertEqual(mock_sleep.mock_calls, expected)
self.assertEqual(base.Scenario.idle_time, 20)
self.assertEqual(scenario.idle_time(), 20)
self.assertRaises(exceptions.InvalidArgumentsException,
base.Scenario.sleep_between, 15, 5)
scenario.sleep_between, 15, 5)
self.assertRaises(exceptions.InvalidArgumentsException,
base.Scenario.sleep_between, -1, 0)
scenario.sleep_between, -1, 0)
self.assertRaises(exceptions.InvalidArgumentsException,
base.Scenario.sleep_between, 0, -2)
scenario.sleep_between, 0, -2)
def test_context(self):
context = {"test": "context"}
class Scenario(base.Scenario):
@classmethod
def init(cls, config):
return context
Scenario._context = Scenario.init({})
self.assertEqual(context, Scenario.context())
context = mock.MagicMock()
scenario = base.Scenario(context=context)
self.assertEqual(context, scenario.context())
def test_clients(self):
nova_client = object()
glance_client = object()
nova_client = mock.MagicMock()
glance_client = mock.MagicMock()
clients = {"nova": nova_client, "glance": glance_client}
class Scenario(base.Scenario):
pass
Scenario._clients = clients
self.assertEqual(nova_client, Scenario.clients("nova"))
self.assertEqual(glance_client, Scenario.clients("glance"))
scenario = base.Scenario(clients=clients)
self.assertEqual(nova_client, scenario.clients("nova"))
self.assertEqual(glance_client, scenario.clients("glance"))
def test_admin_clients(self):
nova_client = object()
glance_client = object()
nova_client = mock.MagicMock()
glance_client = mock.MagicMock()
clients = {"nova": nova_client, "glance": glance_client}
class Scenario(base.Scenario):
pass
Scenario._admin_clients = clients
self.assertEqual(nova_client, Scenario.admin_clients("nova"))
self.assertEqual(glance_client, Scenario.admin_clients("glance"))
scenario = base.Scenario(admin_clients=clients)
self.assertEqual(nova_client, scenario.admin_clients("nova"))
self.assertEqual(glance_client, scenario.admin_clients("glance"))

16
tests/fakes.py
View File

@ -395,22 +395,16 @@ class FakeClients(object):
class FakeScenario(base.Scenario):
idle_time = 0
def idle_time(self):
return 0
@classmethod
def class_init(cls, endpoints):
def do_it(self, **kwargs):
pass
@classmethod
def do_it(cls, **kwargs):
def too_long(self, **kwargs):
pass
@classmethod
def too_long(cls, **kwargs):
pass
@classmethod
def something_went_wrong(cls, **kwargs):
def something_went_wrong(self, **kwargs):
raise Exception("Something went wrong")