openstack/rally-openstack
Code Issues Proposed changes

Port Senlin and others scenarios to new style

Browse Source 
Since current scenario implementation transforms method to class
at runtime, it is reasonable to have class-based scenario
implementation which will be much simpler to use behind the scenes.

This class should be based on Scenario and do not break compatibility.
The only required method is run() which is actually a body of scenario.

This patch contains changes in following groups (scenarios and tests):
/senlin/
/swift/
/tempest/
/vm/
/watcher/
/zaqar/

and modules:

rally/plugins/openstack/context/vm/custom_image.py
tests/unit/test_docstrings.py

Change-Id: Ia7f33d7c279991232286b34abe199d125b92f023
This commit is contained in:
astaroverov 2016-09-01 15:20:15 +03:00
parent a608e91f06
commit f35e901290
12 changed files with 302 additions and 256 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
rally/plugins/openstack/context/vm/custom_image.py
View File

@ -153,7 +153,9 @@ class BaseCustomImageGenerator(context.Context):
flavor_id = types.Flavor.transform(
clients=clients, resource_config=self.config["flavor"])
vm_scenario = vmtasks.VMTasks(self.context, clients=clients)
vm_scenario = vmtasks.BootRuncommandDeleteCustomImage(
self.context,
clients=clients)
glance_wrap = glance_wrapper.wrap(admin_clients.glance, self)

22
rally/plugins/openstack/scenarios/senlin/clusters.py
View File

@ -16,15 +16,18 @@ from rally.plugins.openstack.scenarios.senlin import utils
from rally.task import validation
class SenlinClusters(utils.SenlinScenario):
"""Benchmark scenarios for Senlin clusters."""
"""Scenarios for Senlin clusters."""
@validation.required_openstack(admin=True)
@validation.required_services(consts.Service.SENLIN)
@validation.required_contexts("profiles")
@scenario.configure(context={"cleanup": ["senlin"]})
def create_and_delete_cluster(self, desired_capacity=0, min_size=0,
max_size=-1, timeout=3600, metadata=None):
@validation.required_openstack(admin=True)
@validation.required_services(consts.Service.SENLIN)
@validation.required_contexts("profiles")
@scenario.configure(context={"cleanup": ["senlin"]},
name="SenlinClusters.create_and_delete_cluster")
class CreateAndDeleteCluster(utils.SenlinScenario):
def run(self, desired_capacity=0, min_size=0,
max_size=-1, timeout=3600, metadata=None):
"""Create a cluster and then delete it.
Measure the "senlin cluster-create" and "senlin cluster-delete"
@ -38,7 +41,8 @@ class SenlinClusters(utils.SenlinScenario):
:param timeout: The timeout value in seconds for cluster creation
:param metadata: A set of key value pairs to associate with the cluster
"""
profile_id = self.context["tenant"]["profile"]
cluster = self._create_cluster(profile_id, desired_capacity,
min_size, max_size, timeout, metadata)
self._delete_cluster(cluster)
self._delete_cluster(cluster)

77
rally/plugins/openstack/scenarios/swift/objects.py
View File

@ -22,15 +22,17 @@ from rally.task import atomic
from rally.task import validation
class SwiftObjects(utils.SwiftScenario):
"""Benchmark scenarios for Swift Objects."""
"""Scenarios for Swift Objects."""
@validation.required_services(consts.Service.SWIFT)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["swift"]})
def create_container_and_object_then_list_objects(
self, objects_per_container=1,
object_size=1024, **kwargs):
@validation.required_services(consts.Service.SWIFT)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["swift"]},
name="SwiftObjects.create_container"
"_and_object_then_list_objects")
class CreateContainerAndObjectThenListObjects(utils.SwiftScenario):
def run(self, objects_per_container=1, object_size=1024, **kwargs):
"""Create container and objects then list all objects.
:param objects_per_container: int, number of objects to upload
@ -53,12 +55,15 @@ class SwiftObjects(utils.SwiftScenario):
atomic_action=False)
self._list_objects(container_name)
@validation.required_services(consts.Service.SWIFT)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["swift"]})
def create_container_and_object_then_delete_all(
self, objects_per_container=1,
object_size=1024, **kwargs):
@validation.required_services(consts.Service.SWIFT)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["swift"]},
name="SwiftObjects.create_container"
"_and_object_then_delete_all")
class CreateContainerAndObjectThenDeleteAll(utils.SwiftScenario):
def run(self, objects_per_container=1, object_size=1024, **kwargs):
"""Create container and objects then delete everything created.
:param objects_per_container: int, number of objects to upload
@ -89,12 +94,15 @@ class SwiftObjects(utils.SwiftScenario):
atomic_action=False)
self._delete_container(container_name)
@validation.required_services(consts.Service.SWIFT)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["swift"]})
def create_container_and_object_then_download_object(
self, objects_per_container=1,
object_size=1024, **kwargs):
@validation.required_services(consts.Service.SWIFT)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["swift"]},
name="SwiftObjects.create_container"
"_and_object_then_download_object")
class CreateContainerAndObjectThenDownloadObject(utils.SwiftScenario):
def run(self, objects_per_container=1, object_size=1024, **kwargs):
"""Create container and objects then download all objects.
:param objects_per_container: int, number of objects to upload
@ -124,11 +132,16 @@ class SwiftObjects(utils.SwiftScenario):
self._download_object(container_name, object_name,
atomic_action=False)
@validation.required_services(consts.Service.SWIFT)
@validation.required_openstack(users=True)
@scenario.configure(context={"swift_objects": {}})
def list_objects_in_containers(self):
@validation.required_services(consts.Service.SWIFT)
@validation.required_openstack(users=True)
@scenario.configure(context={"swift_objects": {}},
name="SwiftObjects.list_objects_in_containers")
class ListObjectsInContainers(utils.SwiftScenario):
def run(self):
"""List objects in all containers."""
containers = self._list_containers()[1]
key_suffix = "container"
@ -139,11 +152,17 @@ class SwiftObjects(utils.SwiftScenario):
for container in containers:
self._list_objects(container["name"], atomic_action=False)
@validation.required_services(consts.Service.SWIFT)
@validation.required_openstack(users=True)
@scenario.configure(context={"swift_objects": {}})
def list_and_download_objects_in_containers(self):
@validation.required_services(consts.Service.SWIFT)
@validation.required_openstack(users=True)
@scenario.configure(context={"swift_objects": {}},
name="SwiftObjects.list_and_"
"download_objects_in_containers")
class ListAndDownloadObjectsInContainers(utils.SwiftScenario):
def run(self):
"""List and download objects in all containers."""
containers = self._list_containers()[1]
list_key_suffix = "container"
@ -169,4 +188,4 @@ class SwiftObjects(utils.SwiftScenario):
for container_name, objects in objects_dict.items():
for obj in objects:
self._download_object(container_name, obj["name"],
atomic_action=False)
atomic_action=False)

124
rally/plugins/openstack/scenarios/vm/vmtasks.py
View File

@ -27,46 +27,36 @@ from rally.task import atomic
from rally.task import types
from rally.task import validation
"""Scenarios that are to be run inside VM instances."""
LOG = logging.getLogger(__name__)
class VMTasks(vm_utils.VMScenario):
"""Benchmark scenarios that are to be run inside VM instances."""
@types.convert(image={"type": "glance_image"},
flavor={"type": "nova_flavor"})
@validation.image_valid_on_flavor("flavor", "image")
@validation.valid_command("command")
@validation.number("port", minval=1, maxval=65535, nullable=True,
integer_only=True)
@validation.external_network_exists("floating_network")
@validation.required_services(consts.Service.NOVA, consts.Service.CINDER)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["nova", "cinder"],
"keypair": {}, "allow_ssh": {}},
name="VMTasks.boot_runcommand_delete")
class BootRuncommandDelete(vm_utils.VMScenario):
def __init__(self, *args, **kwargs):
super(VMTasks, self).__init__(*args, **kwargs)
super(BootRuncommandDelete, self).__init__(*args, **kwargs)
@types.convert(image={"type": "glance_image"},
flavor={"type": "nova_flavor"})
@validation.image_valid_on_flavor("flavor", "image")
@validation.valid_command("command")
@validation.number("port", minval=1, maxval=65535, nullable=True,
integer_only=True)
@validation.external_network_exists("floating_network")
@validation.required_services(consts.Service.NOVA, consts.Service.CINDER)
@validation.required_openstack(users=True)
@scenario.configure(context={"cleanup": ["nova", "cinder"],
"keypair": {}, "allow_ssh": {}})
def boot_runcommand_delete(self, image, flavor,
username,
password=None,
command=None,
volume_args=None,
floating_network=None,
port=22,
use_floating_ip=True,
force_delete=False,
wait_for_ping=True,
max_log_length=None,
**kwargs):
def run(self, image, flavor, username, password=None, command=None,
volume_args=None, floating_network=None, port=22,
use_floating_ip=True, force_delete=False, wait_for_ping=True,
max_log_length=None, **kwargs):
"""Boot a server, run script specified in command and delete server.
Example Script in samples/tasks/support/instance_dd_test.sh
The script to be executed is provided like command['remote_path'] or
command['local_path'] and interpreter in command['interpreter']
respectively.
:param image: glance image name to use for the vm
:param flavor: VM flavor name
:param username: ssh username on server, str
@ -223,46 +213,60 @@ class VMTasks(vm_utils.VMScenario):
for chart in charts:
self.add_output(**{chart_type: chart})
@types.convert(image={"type": "glance_image"},
flavor={"type": "nova_flavor"})
@validation.number("port", minval=1, maxval=65535, nullable=True,
integer_only=True)
@validation.valid_command("command")
@validation.external_network_exists("floating_network")
@validation.required_services(consts.Service.NOVA, consts.Service.CINDER)
@validation.required_openstack(users=True)
@validation.required_contexts("image_command_customizer")
@scenario.configure(context={"cleanup": ["nova", "cinder"],
"keypair": {}, "allow_ssh": {}})
def boot_runcommand_delete_custom_image(self, **kwargs):
@types.convert(image={"type": "glance_image"},
flavor={"type": "nova_flavor"})
@validation.number("port", minval=1, maxval=65535, nullable=True,
integer_only=True)
@validation.valid_command("command")
@validation.external_network_exists("floating_network")
@validation.required_services(consts.Service.NOVA, consts.Service.CINDER)
@validation.required_openstack(users=True)
@validation.required_contexts("image_command_customizer")
@scenario.configure(context={"cleanup": ["nova", "cinder"],
"keypair": {}, "allow_ssh": {}},
name="VMTasks.boot_runcommand_delete_custom_image")
class BootRuncommandDeleteCustomImage(vm_utils.VMScenario):
def __init__(self, *args, **kwargs):
super(BootRuncommandDeleteCustomImage, self).__init__(*args, **kwargs)
def run(self, **kwargs):
"""Boot a server from a custom image, run a command that outputs JSON.
Example Script in rally-jobs/extra/install_benchmark.sh
"""
return self.boot_runcommand_delete(
boot_runcommand_delete = BootRuncommandDelete(self.context)
return boot_runcommand_delete.run(
image=self.context["tenant"]["custom_image"]["id"], **kwargs)
@scenario.configure(context={"cleanup": ["nova", "heat"],
"keypair": {}, "network": {}})
def runcommand_heat(self, workload, template, files, parameters):
@scenario.configure(context={"cleanup": ["nova", "heat"],
"keypair": {}, "network": {}},
name="VMTasks.runcommand_heat")
class RuncommandHeat(vm_utils.VMScenario):
def __init__(self, *args, **kwargs):
super(RuncommandHeat, self).__init__(*args, **kwargs)
def run(self, workload, template, files, parameters):
"""Run workload on stack deployed by heat.
Workload can be either file or resource:
Workload can be either file or resource:
.. code-block: json
.. code-block: json
{"file": "/path/to/file.sh"}
{"resource": ["package.module", "workload.py"]}
{"file": "/path/to/file.sh"}
{"resource": ["package.module", "workload.py"]}
Also it should contain "username" key.
Also it should contain "username" key.
Given file will be uploaded to `gate_node` and started. This script
should print `key` `value` pairs separated by colon. These pairs will
be presented in results.
Given file will be uploaded to `gate_node` and started. This script
should print `key` `value` pairs separated by colon. These pairs will
be presented in results.
Gate node should be accessible via ssh with keypair `key_name`, so
heat template should accept parameter `key_name`.
Gate node should be accessible via ssh with keypair `key_name`, so
heat template should accept parameter `key_name`.
:param workload: workload to run
:param template: path to heat template file
@ -310,4 +314,4 @@ class VMTasks(vm_utils.VMScenario):
"data": {
"cols": ["key", "value"],
"rows": rows}}
)
)

46
rally/plugins/openstack/scenarios/watcher/basic.py
View File

@ -17,15 +17,18 @@ from rally.task import types
from rally.task import validation
class Watcher(utils.WatcherScenario):
"""Benchmark scenarios for Watcher servers."""
"""Scenarios for Watcher servers."""
@types.convert(strategy={"type": "watcher_strategy"},
goal={"type": "watcher_goal"})
@validation.required_services(consts.Service.WATCHER)
@validation.required_openstack(admin=True)
@scenario.configure(context={"admin_cleanup": ["watcher"]})
def create_audit_template_and_delete(self, goal, strategy, extra=None):
@types.convert(strategy={"type": "watcher_strategy"},
goal={"type": "watcher_goal"})
@validation.required_services(consts.Service.WATCHER)
@validation.required_openstack(admin=True)
@scenario.configure(context={"admin_cleanup": ["watcher"]},
name="Watcher.create_audit_template_and_delete")
class CreateAuditTemplateAndDelete(utils.WatcherScenario):
def run(self, goal, strategy, extra=None):
"""Create audit template and delete it.
:param goal: The goal audit template is based on
@ -39,11 +42,14 @@ class Watcher(utils.WatcherScenario):
audit_template = self._create_audit_template(goal, strategy, extra)
self._delete_audit_template(audit_template.uuid)
@validation.required_services(consts.Service.WATCHER)
@scenario.configure()
def list_audit_templates(self, name=None, goal=None, strategy=None,
limit=None, sort_key=None, sort_dir=None,
detail=False):
@validation.required_services(consts.Service.WATCHER)
@scenario.configure(name="Watcher.list_audit_templates")
class ListAuditTemplates(utils.WatcherScenario):
def run(self, name=None, goal=None, strategy=None,
limit=None, sort_key=None, sort_dir=None,
detail=False):
"""List existing audit templates.
Audit templates are being created by Audit Template Context.
@ -69,10 +75,14 @@ class Watcher(utils.WatcherScenario):
limit=limit, sort_key=sort_key,
sort_dir=sort_dir, detail=detail)
@validation.required_services(consts.Service.WATCHER)
@validation.required_contexts("audit_templates")
@scenario.configure(context={"admin_cleanup": ["watcher"]})
def create_audit_and_delete(self):
@validation.required_services(consts.Service.WATCHER)
@validation.required_contexts("audit_templates")
@scenario.configure(context={"admin_cleanup": ["watcher"]},
name="Watcher.create_audit_and_delete")
class CreateAuditAndDelete(utils.WatcherScenario):
def run(self):
"""Create and delete audit.
Create Audit, wait until whether Audit is in SUCCEEDED state or in
@ -81,4 +91,4 @@ class Watcher(utils.WatcherScenario):
audit_template_uuid = self.context["audit_templates"][0]
audit = self._create_audit(audit_template_uuid)
self._delete_audit(audit)
self._delete_audit(audit)

23
rally/plugins/openstack/scenarios/zaqar/basic.py
View File

@ -19,14 +19,17 @@ from rally.plugins.openstack import scenario
from rally.plugins.openstack.scenarios.zaqar import utils as zutils
class ZaqarBasic(zutils.ZaqarScenario):
"""Benchmark scenarios for Zaqar."""
"""Scenarios for Zaqar."""
@scenario.configure(context={"cleanup": ["zaqar"]},
name="ZaqarBasic.create_queue")
class CreateQueue(zutils.ZaqarScenario):
@scenario.configure(context={"cleanup": ["zaqar"]})
@logging.log_deprecated_args(
"The 'name_length' argument to create_queue is ignored",
"0.1.2", ["name_length"], once=True)
def create_queue(self, name_length=None, **kwargs):
def run(self, name_length=None, **kwargs):
"""Create a Zaqar queue with a random name.
:param kwargs: other optional parameters to create queues like
@ -34,12 +37,16 @@ class ZaqarBasic(zutils.ZaqarScenario):
"""
self._queue_create(**kwargs)
@scenario.configure(context={"cleanup": ["zaqar"]})
@scenario.configure(context={"cleanup": ["zaqar"]},
name="ZaqarBasic.producer_consumer")
class ProducerConsumer(zutils.ZaqarScenario):
@logging.log_deprecated_args(
"The 'name_length' argument to producer_consumer is ignored",
"0.1.2", ["name_length"], once=True)
def producer_consumer(self, name_length=None,
min_msg_count=50, max_msg_count=200, **kwargs):
def run(self, name_length=None,
min_msg_count=50, max_msg_count=200, **kwargs):
"""Serial message producer/consumer.
Creates a Zaqar queue with random name, sends a set of messages
@ -57,4 +64,4 @@ class ZaqarBasic(zutils.ZaqarScenario):
in range(msg_count)]
self._messages_post(queue, messages, min_msg_count, max_msg_count)
self._messages_list(queue)
self._queue_delete(queue)
self._queue_delete(queue)

32
tests/unit/plugins/openstack/context/vm/test_custom_image.py
View File

@ -62,26 +62,26 @@ class BaseCustomImageContextVMTestCase(test.TestCase):
}
})
@mock.patch("%s.vmtasks.VMTasks" % BASE)
@mock.patch("%s.osclients.Clients" % BASE)
@mock.patch("%s.types.GlanceImage.transform" % BASE, return_value="image")
@mock.patch("%s.types.Flavor.transform" % BASE, return_value="flavor")
@mock.patch("rally.plugins.openstack.wrappers.glance.wrap")
@mock.patch("%s.vmtasks.BootRuncommandDeleteCustomImage" % BASE)
def test_create_one_image(
self, mock_glance_wrap, mock_flavor_transform,
mock_glance_image_transform, mock_clients, mock_vm_tasks):
self, mock_scenario, mock_glance_wrap, mock_flavor_transform,
mock_glance_image_transform, mock_clients
):
ip = {"ip": "foo_ip", "id": "foo_id", "is_floating": True}
fake_server = mock.Mock()
fake_image = mock.MagicMock(
to_dict=mock.MagicMock(return_value={"id": "image"}))
mock_vm_scenario = mock_vm_tasks.return_value = mock.MagicMock(
scenario = mock_scenario.return_value = mock.MagicMock(
_create_image=mock.MagicMock(return_value=fake_image),
_boot_server_with_fip=mock.MagicMock(
return_value=(fake_server, ip))
)
generator_ctx = TestImageGenerator(self.context)
generator_ctx._customize_image = mock.MagicMock()
@ -103,47 +103,47 @@ class BaseCustomImageContextVMTestCase(test.TestCase):
mock_glance_image_transform.assert_called_once_with(
clients=mock_clients.return_value,
resource_config={"name": "image"})
mock_vm_tasks.assert_called_once_with(
mock_scenario.assert_called_once_with(
self.context, clients=mock_clients.return_value)
mock_vm_scenario._boot_server_with_fip.assert_called_once_with(
scenario._boot_server_with_fip.assert_called_once_with(
image="image", flavor="flavor",
floating_network="floating",
key_name="keypair_name", security_groups=["secgroup_name"],
userdata=None, foo_arg="foo_value")
mock_vm_scenario._stop_server.assert_called_once_with(fake_server)
scenario._stop_server.assert_called_once_with(fake_server)
generator_ctx._customize_image.assert_called_once_with(
fake_server, ip, user)
mock_vm_scenario._create_image.assert_called_once_with(fake_server)
scenario._create_image.assert_called_once_with(fake_server)
mock_glance_wrap.return_value.set_visibility.assert_called_once_with(
fake_image)
mock_vm_scenario._delete_server_with_fip.assert_called_once_with(
scenario._delete_server_with_fip.assert_called_once_with(
fake_server, ip)
self.assertEqual({"id": "image"}, custom_image)
@mock.patch("%s.vmtasks.VMTasks" % BASE)
@mock.patch("%s.osclients.Clients" % BASE)
@mock.patch("%s.types.GlanceImage.transform" % BASE,
return_value="image")
@mock.patch("%s.types.Flavor.transform" % BASE,
return_value="flavor")
@mock.patch("rally.plugins.openstack.wrappers.glance.wrap")
@mock.patch("%s.vmtasks.BootRuncommandDeleteCustomImage" % BASE)
def test_create_one_image_cleanup(
self, mock_glance_wrap, mock_flavor_transform,
mock_glance_image_transform, mock_clients,
mock_vm_tasks):
self, mock_scenario, mock_glance_wrap, mock_flavor_transform,
mock_glance_image_transform, mock_clients
):
ip = {"ip": "foo_ip", "id": "foo_id", "is_floating": True}
fake_server = mock.Mock()
fake_image = mock.MagicMock(
to_dict=mock.MagicMock(return_value={"id": "image"}))
mock_vm_scenario = mock_vm_tasks.return_value = mock.MagicMock(
scenario = mock_scenario.return_value = mock.MagicMock(
_create_image=mock.MagicMock(return_value=fake_image),
_boot_server_with_fip=mock.MagicMock(
return_value=(fake_server, ip)),
@ -167,7 +167,7 @@ class BaseCustomImageContextVMTestCase(test.TestCase):
generator_ctx._customize_image.assert_called_once_with(
fake_server, ip, user)
mock_vm_scenario._delete_server_with_fip.assert_called_once_with(
scenario._delete_server_with_fip.assert_called_once_with(
fake_server, ip)
@mock.patch("%s.nova_utils.NovaScenario" % BASE)

7
tests/unit/plugins/openstack/scenarios/senlin/test_clusters.py
View File

@ -21,13 +21,12 @@ class SenlinClustersTestCase(test.ScenarioTestCase):
def test_create_and_delete_cluster(self):
mock_cluster = mock.Mock()
self.context["tenant"] = {"profile": "fake_profile_id"}
scenario = clusters.SenlinClusters(self.context)
scenario = clusters.CreateAndDeleteCluster(self.context)
scenario._create_cluster = mock.Mock(return_value=mock_cluster)
scenario._delete_cluster = mock.Mock()
scenario.create_and_delete_cluster(desired_capacity=1, min_size=0,
max_size=3, timeout=60,
metadata={"k2": "v2"})
scenario.run(desired_capacity=1, min_size=0,
max_size=3, timeout=60, metadata={"k2": "v2"})
scenario._create_cluster.assert_called_once_with("fake_profile_id",
1, 0, 3, 60,

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

@ -24,14 +24,13 @@ from tests.unit import test
class SwiftObjectsTestCase(test.ScenarioTestCase):
def test_create_container_and_object_then_list_objects(self):
scenario = objects.SwiftObjects(self.context)
scenario = objects.CreateContainerAndObjectThenListObjects(
self.context)
scenario._create_container = mock.MagicMock(return_value="AA")
scenario._upload_object = mock.MagicMock()
scenario._list_objects = mock.MagicMock()
scenario.create_container_and_object_then_list_objects(
objects_per_container=5,
object_size=100)
scenario.run(objects_per_container=5, object_size=100)
self.assertEqual(1, scenario._create_container.call_count)
self.assertEqual(5, scenario._upload_object.call_count)
@ -41,16 +40,14 @@ class SwiftObjectsTestCase(test.ScenarioTestCase):
"swift.create_5_objects")
def test_create_container_and_object_then_delete_all(self):
scenario = objects.SwiftObjects(self.context)
scenario = objects.CreateContainerAndObjectThenDeleteAll(self.context)
scenario._create_container = mock.MagicMock(return_value="BB")
scenario._upload_object = mock.MagicMock(
side_effect=[("etaaag", "ooobj_%i" % i) for i in range(3)])
scenario._delete_object = mock.MagicMock()
scenario._delete_container = mock.MagicMock()
scenario.create_container_and_object_then_delete_all(
objects_per_container=3,
object_size=10)
scenario.run(objects_per_container=3, object_size=10)
self.assertEqual(1, scenario._create_container.call_count)
self.assertEqual(3, scenario._upload_object.call_count)
@ -65,15 +62,15 @@ class SwiftObjectsTestCase(test.ScenarioTestCase):
"swift.delete_3_objects")
def test_create_container_and_object_then_download_object(self):
scenario = objects.SwiftObjects(self.context)
scenario = objects.CreateContainerAndObjectThenDownloadObject(
self.context
)
scenario._create_container = mock.MagicMock(return_value="CC")
scenario._upload_object = mock.MagicMock(
side_effect=[("etaaaag", "obbbj_%i" % i) for i in range(2)])
scenario._download_object = mock.MagicMock()
scenario.create_container_and_object_then_download_object(
objects_per_container=2,
object_size=50)
scenario.run(objects_per_container=2, object_size=50)
self.assertEqual(1, scenario._create_container.call_count)
self.assertEqual(2, scenario._upload_object.call_count)
@ -89,12 +86,12 @@ class SwiftObjectsTestCase(test.ScenarioTestCase):
@ddt.data(1, 5)
def test_list_objects_in_containers(self, num_cons):
con_list = [{"name": "cooon_%s" % i} for i in range(num_cons)]
scenario = objects.SwiftObjects()
scenario = objects.ListObjectsInContainers(self.context)
scenario._list_containers = mock.MagicMock(return_value=("header",
con_list))
scenario._list_objects = mock.MagicMock()
scenario.list_objects_in_containers()
scenario.run()
scenario._list_containers.assert_called_once_with()
con_calls = [mock.call(container["name"], atomic_action=False)
for container in con_list]
@ -111,14 +108,14 @@ class SwiftObjectsTestCase(test.ScenarioTestCase):
def test_list_and_download_objects_in_containers(self, num_cons, num_objs):
con_list = [{"name": "connn_%s" % i} for i in range(num_cons)]
obj_list = [{"name": "ooobj_%s" % i} for i in range(num_objs)]
scenario = objects.SwiftObjects()
scenario = objects.ListAndDownloadObjectsInContainers(self.context)
scenario._list_containers = mock.MagicMock(return_value=("header",
con_list))
scenario._list_objects = mock.MagicMock(return_value=("header",
obj_list))
scenario._download_object = mock.MagicMock()
scenario.list_and_download_objects_in_containers()
scenario.run()
scenario._list_containers.assert_called_once_with()
con_calls = [mock.call(container["name"], atomic_action=False)
for container in con_list]
@ -146,13 +143,12 @@ class SwiftObjectsTestCase(test.ScenarioTestCase):
def test_functional_create_container_and_object_then_list_objects(self):
names_list = ["AA", "BB", "CC", "DD"]
scenario = objects.SwiftObjects(self.context)
scenario = objects.CreateContainerAndObjectThenListObjects(
self.context)
scenario.generate_random_name = mock.MagicMock(side_effect=names_list)
scenario._list_objects = mock.MagicMock()
scenario.create_container_and_object_then_list_objects(
objects_per_container=3,
object_size=100)
scenario.run(objects_per_container=3, object_size=100)
scenario._list_objects.assert_called_once_with("AA")
@ -162,14 +158,12 @@ class SwiftObjectsTestCase(test.ScenarioTestCase):
def test_functional_create_container_and_object_then_delete_all(self):
names_list = ["111", "222", "333", "444", "555"]
scenario = objects.SwiftObjects(self.context)
scenario = objects.CreateContainerAndObjectThenDeleteAll(self.context)
scenario.generate_random_name = mock.MagicMock(side_effect=names_list)
scenario._delete_object = mock.MagicMock()
scenario._delete_container = mock.MagicMock()
scenario.create_container_and_object_then_delete_all(
objects_per_container=4,
object_size=240)
scenario.run(objects_per_container=4, object_size=240)
scenario._delete_object.assert_has_calls(
[mock.call("111", name,
@ -184,13 +178,12 @@ class SwiftObjectsTestCase(test.ScenarioTestCase):
def test_functional_create_container_and_object_then_download_object(self):
names_list = ["aaa", "bbb", "ccc", "ddd", "eee", "fff"]
scenario = objects.SwiftObjects(self.context)
scenario = objects.CreateContainerAndObjectThenDownloadObject(
self.context)
scenario.generate_random_name = mock.MagicMock(side_effect=names_list)
scenario._download_object = mock.MagicMock()
scenario.create_container_and_object_then_download_object(
objects_per_container=5,
object_size=750)
scenario.run(objects_per_container=5, object_size=750)
scenario._download_object.assert_has_calls(
[mock.call("aaa", name,

140
tests/unit/plugins/openstack/scenarios/vm/test_vmtasks.py
View File

@ -21,6 +21,9 @@ from rally.plugins.openstack.scenarios.vm import vmtasks
from tests.unit import test
BASE = "rally.plugins.openstack.scenarios.vm.vmtasks"
@ddt.ddt
class VMTasksTestCase(test.ScenarioTestCase):
@ -28,49 +31,50 @@ class VMTasksTestCase(test.ScenarioTestCase):
super(VMTasksTestCase, self).setUp()
self.context.update({"user": {"keypair": {"name": "keypair_name"},
"credential": mock.MagicMock()}})
self.scenario = vmtasks.VMTasks(context=self.context)
def create_env(self, scenario):
self.ip = {"id": "foo_id", "ip": "foo_ip", "is_floating": True}
self.scenario._boot_server_with_fip = mock.Mock(
scenario._boot_server_with_fip = mock.Mock(
return_value=("foo_server", self.ip))
self.scenario._wait_for_ping = mock.Mock()
self.scenario._delete_server_with_fip = mock.Mock()
self.scenario._create_volume = mock.Mock(
scenario._wait_for_ping = mock.Mock()
scenario._delete_server_with_fip = mock.Mock()
scenario._create_volume = mock.Mock(
return_value=mock.Mock(id="foo_volume"))
self.scenario._run_command = mock.MagicMock(
scenario._run_command = mock.MagicMock(
return_value=(0, "{\"foo\": 42}", "foo_err"))
self.scenario.add_output = mock.Mock()
scenario.add_output = mock.Mock()
return scenario
def test_boot_runcommand_delete(self):
self.scenario._run_command = mock.MagicMock(
scenario = self.create_env(vmtasks.BootRuncommandDelete(self.context))
scenario._run_command = mock.MagicMock(
return_value=(0, "{\"foo\": 42}", "foo_err"))
self.scenario.boot_runcommand_delete(
"foo_image", "foo_flavor",
command={"script_file": "foo_script",
"interpreter": "foo_interpreter"},
username="foo_username",
password="foo_password",
use_floating_ip="use_fip",
floating_network="ext_network",
force_delete="foo_force",
volume_args={"size": 16},
foo_arg="foo_value")
scenario.run("foo_image", "foo_flavor",
command={"script_file": "foo_script",
"interpreter": "foo_interpreter"},
username="foo_username",
password="foo_password",
use_floating_ip="use_fip",
floating_network="ext_network",
force_delete="foo_force",
volume_args={"size": 16},
foo_arg="foo_value")
self.scenario._create_volume.assert_called_once_with(
16, imageRef=None)
self.scenario._boot_server_with_fip.assert_called_once_with(
scenario._create_volume.assert_called_once_with(16, imageRef=None)
scenario._boot_server_with_fip.assert_called_once_with(
"foo_image", "foo_flavor", key_name="keypair_name",
use_floating_ip="use_fip", floating_network="ext_network",
block_device_mapping={"vdrally": "foo_volume:::1"},
foo_arg="foo_value")
self.scenario._wait_for_ping.assert_called_once_with("foo_ip")
self.scenario._run_command.assert_called_once_with(
scenario._wait_for_ping.assert_called_once_with("foo_ip")
scenario._run_command.assert_called_once_with(
"foo_ip", 22, "foo_username", "foo_password",
command={"script_file": "foo_script",
"interpreter": "foo_interpreter"})
self.scenario._delete_server_with_fip.assert_called_once_with(
scenario._delete_server_with_fip.assert_called_once_with(
"foo_server", self.ip, force_delete="foo_force")
self.scenario.add_output.assert_called_once_with(
scenario.add_output.assert_called_once_with(
additive={"title": "Command output", "chart_plugin": "Lines",
"data": [["foo", 42.0]]})
@ -93,7 +97,9 @@ class VMTasksTestCase(test.ScenarioTestCase):
@ddt.unpack
def test_boot_runcommand_delete_add_output(self, output,
expected=None, raises=None):
self.scenario._run_command.return_value = output
scenario = self.create_env(vmtasks.BootRuncommandDelete(self.context))
scenario._run_command.return_value = output
kwargs = {"command": {"remote_path": "foo"},
"username": "foo_username",
"password": "foo_password",
@ -103,48 +109,50 @@ class VMTasksTestCase(test.ScenarioTestCase):
"volume_args": {"size": 16},
"foo_arg": "foo_value"}
if raises:
self.assertRaises(raises, self.scenario.boot_runcommand_delete,
self.assertRaises(raises, scenario.run,
"foo_image", "foo_flavor", **kwargs)
self.assertFalse(self.scenario.add_output.called)
self.assertFalse(scenario.add_output.called)
else:
self.scenario.boot_runcommand_delete("foo_image", "foo_flavor",
**kwargs)
scenario.run("foo_image", "foo_flavor", **kwargs)
calls = [mock.call(**kw) for kw in expected]
self.scenario.add_output.assert_has_calls(calls, any_order=True)
scenario.add_output.assert_has_calls(calls, any_order=True)
self.scenario._create_volume.assert_called_once_with(
16, imageRef=None)
self.scenario._boot_server_with_fip.assert_called_once_with(
scenario._create_volume.assert_called_once_with(16, imageRef=None)
scenario._boot_server_with_fip.assert_called_once_with(
"foo_image", "foo_flavor", key_name="keypair_name",
use_floating_ip="use_fip", floating_network="ext_network",
block_device_mapping={"vdrally": "foo_volume:::1"},
foo_arg="foo_value")
self.scenario._run_command.assert_called_once_with(
scenario._run_command.assert_called_once_with(
"foo_ip", 22, "foo_username", "foo_password",
command={"remote_path": "foo"})
self.scenario._delete_server_with_fip.assert_called_once_with(
scenario._delete_server_with_fip.assert_called_once_with(
"foo_server", self.ip, force_delete="foo_force")
def test_boot_runcommand_delete_command_timeouts(self):
self.scenario._run_command.side_effect = exceptions.SSHTimeout()
scenario = self.create_env(vmtasks.BootRuncommandDelete(self.context))
scenario._run_command.side_effect = exceptions.SSHTimeout()
self.assertRaises(exceptions.SSHTimeout,
self.scenario.boot_runcommand_delete,
scenario.run,
"foo_image", "foo_flavor", "foo_interpreter",
"foo_script", "foo_username")
self.scenario._delete_server_with_fip.assert_called_once_with(
scenario._delete_server_with_fip.assert_called_once_with(
"foo_server", self.ip, force_delete=False)
self.assertFalse(self.scenario.add_output.called)
self.assertFalse(scenario.add_output.called)
def test_boot_runcommand_delete_ping_wait_timeouts(self):
self.scenario._wait_for_ping.side_effect = exceptions.TimeoutException(
scenario = self.create_env(vmtasks.BootRuncommandDelete(self.context))
scenario._wait_for_ping.side_effect = exceptions.TimeoutException(
resource_type="foo_resource",
resource_name="foo_name",
resource_id="foo_id",
desired_status="foo_desired_status",
resource_status="foo_resource_status")
exc = self.assertRaises(exceptions.TimeoutException,
self.scenario.boot_runcommand_delete,
scenario.run,
"foo_image", "foo_flavor", "foo_interpreter",
"foo_script", "foo_username",
wait_for_ping=True)
@ -154,22 +162,25 @@ class VMTasksTestCase(test.ScenarioTestCase):
self.assertEqual(exc.kwargs["desired_status"], "foo_desired_status")
self.assertEqual(exc.kwargs["resource_status"], "foo_resource_status")
self.scenario._delete_server_with_fip.assert_called_once_with(
scenario._delete_server_with_fip.assert_called_once_with(
"foo_server", self.ip, force_delete=False)
self.assertFalse(self.scenario.add_output.called)
self.assertFalse(scenario.add_output.called)
@mock.patch("rally.plugins.openstack.scenarios.vm.vmtasks.json")
@mock.patch("%s.json" % BASE)
def test_boot_runcommand_delete_json_fails(self, mock_json):
scenario = self.create_env(vmtasks.BootRuncommandDelete(self.context))
mock_json.loads.side_effect = ValueError()
self.assertRaises(exceptions.ScriptError,
self.scenario.boot_runcommand_delete,
scenario.run,
"foo_image", "foo_flavor", "foo_interpreter",
"foo_script", "foo_username")
self.scenario._delete_server_with_fip.assert_called_once_with(
scenario._delete_server_with_fip.assert_called_once_with(
"foo_server", self.ip, force_delete=False)
self.assertFalse(self.scenario.add_output.called)
self.assertFalse(scenario.add_output.called)
def test_boot_runcommand_delete_custom_image(self):
@mock.patch("%s.BootRuncommandDelete.run" % BASE)
def test_boot_runcommand_delete_custom_image(self, mock_scenario):
context = {
"user": {
"tenant_id": "tenant_id",
@ -179,26 +190,23 @@ class VMTasksTestCase(test.ScenarioTestCase):
"custom_image": {"id": "image_id"}
}
}
scenario = vmtasks.VMTasks(context)
scenario = vmtasks.BootRuncommandDeleteCustomImage(context)
scenario.boot_runcommand_delete = mock.Mock()
scenario.run(flavor="flavor_id",
command={
"script_file": "foo_script",
"interpreter": "bar_interpreter"},
username="username")
scenario.boot_runcommand_delete_custom_image(
flavor="flavor_id",
command={
"script_file": "foo_script",
"interpreter": "bar_interpreter"},
username="username")
scenario.boot_runcommand_delete.assert_called_once_with(
mock_scenario.assert_called_once_with(
image="image_id", flavor="flavor_id", username="username",
command={
"script_file": "foo_script",
"interpreter": "bar_interpreter"}
)
@mock.patch("rally.plugins.openstack.scenarios.vm.vmtasks.heat")
@mock.patch("rally.plugins.openstack.scenarios.vm.vmtasks.sshutils")
@mock.patch("%s.heat" % BASE)
@mock.patch("%s.sshutils" % BASE)
def test_runcommand_heat(self, mock_sshutils, mock_heat):
fake_ssh = mock.Mock()
fake_ssh.execute.return_value = [0, "key:val", ""]
@ -212,14 +220,14 @@ class VMTasksTestCase(test.ScenarioTestCase):
"credential": "ok"},
"tenant": {"networks": [{"router_id": "1"}]}
}
scenario = vmtasks.VMTasks(context)
scenario = vmtasks.RuncommandHeat(context)
scenario.generate_random_name = mock.Mock(return_value="name")
scenario.add_output = mock.Mock()
workload = {"username": "admin",
"resource": ["foo", "bar"]}
scenario.runcommand_heat(workload, "template",
{"file_key": "file_value"},
{"param_key": "param_value"})
scenario.run(workload, "template",
{"file_key": "file_value"},
{"param_key": "param_value"})
expected = {"chart_plugin": "Table",
"data": {"rows": [["key", "val"]],
"cols": ["key", "value"]},

12
tests/unit/plugins/openstack/scenarios/watcher/test_basic.py
View File

@ -22,12 +22,12 @@ from tests.unit import test
class WatcherTestCase(test.ScenarioTestCase):
def test_create_audit_template_and_delete(self):
scenario = basic.Watcher(self.context)
scenario = basic.CreateAuditTemplateAndDelete(self.context)
audit_template = mock.Mock()
scenario._create_audit_template = mock.MagicMock(
return_value=audit_template)
scenario._delete_audit_template = mock.MagicMock()
scenario.create_audit_template_and_delete("goal", "strategy", {})
scenario.run("goal", "strategy", {})
scenario._create_audit_template.assert_called_once_with("goal",
"strategy",
{})
@ -35,20 +35,20 @@ class WatcherTestCase(test.ScenarioTestCase):
audit_template.uuid)
def test_list_audit_template(self):
scenario = basic.Watcher(self.context)
scenario = basic.ListAuditTemplates(self.context)
scenario._list_audit_templates = mock.MagicMock()
scenario.list_audit_templates()
scenario.run()
scenario._list_audit_templates.assert_called_once_with(
detail=False, goal=None, limit=None, name=None, sort_dir=None,
sort_key=None, strategy=None)
def test_create_audit_and_delete(self):
mock_audit = mock.MagicMock()
scenario = basic.Watcher(self.context)
scenario = basic.CreateAuditAndDelete(self.context)
scenario.context = mock.MagicMock()
scenario._create_audit = mock.MagicMock(return_value=mock_audit)
scenario.sleep_between = mock.MagicMock()
scenario._delete_audit = mock.MagicMock()
scenario.create_audit_and_delete()
scenario.run()
scenario._create_audit.assert_called_once_with(mock.ANY)
scenario._delete_audit.assert_called_once_with(mock_audit)

22
tests/unit/plugins/openstack/scenarios/zaqar/test_basic.py
View File

@ -17,22 +17,23 @@ import mock
from rally.plugins.openstack.scenarios.zaqar import basic
from tests.unit import test
BASE = "rally.plugins.openstack.scenarios.zaqar."
BASIC = BASE + "basic.ZaqarBasic."
BASE = "rally.plugins.openstack.scenarios.zaqar.basic"
class ZaqarBasicTestCase(test.ScenarioTestCase):
@mock.patch(BASIC + "generate_random_name", return_value="fizbit")
def test_create_queue(self, mock_generate_random_name):
scenario = basic.ZaqarBasic(self.context)
@mock.patch("%s.CreateQueue.generate_random_name" % BASE,
return_value="fizbit")
def test_create_queue(self, mock_random_name):
scenario = basic.CreateQueue(self.context)
scenario._queue_create = mock.MagicMock()
scenario.create_queue(fakearg="fake")
scenario.run(fakearg="fake")
scenario._queue_create.assert_called_once_with(fakearg="fake")
@mock.patch(BASIC + "generate_random_name", return_value="kitkat")
def test_producer_consumer(self, mock_generate_random_name):
scenario = basic.ZaqarBasic(self.context)
@mock.patch("%s.CreateQueue.generate_random_name" % BASE,
return_value="kitkat")
def test_producer_consumer(self, mock_random_name):
scenario = basic.ProducerConsumer(self.context)
messages = [{"body": {"id": idx}, "ttl": 360} for idx
in range(20)]
queue = mock.MagicMock()
@ -42,8 +43,7 @@ class ZaqarBasicTestCase(test.ScenarioTestCase):
scenario._messages_list = mock.MagicMock()
scenario._queue_delete = mock.MagicMock()
scenario.producer_consumer(min_msg_count=20, max_msg_count=20,
fakearg="fake")
scenario.run(min_msg_count=20, max_msg_count=20, fakearg="fake")
scenario._queue_create.assert_called_once_with(fakearg="fake")
scenario._messages_post.assert_called_once_with(queue, messages,