Merge "Switch cinder scenarios to cinder service"

rally-jobs/cinder.yaml

@@ -179,8 +179,7 @@
     -
       args:
         update_volume_kwargs:
-           display_name: "name_updated"
+           description: "desc_updated"
-           display_description: "desc_updated"
         size: 1
       runner:
         type: "constant"
@@ -196,8 +195,7 @@
     -
       args:
         update_volume_kwargs:
-           display_name: "name_updated"
+           description: "desc_updated"
-           display_description: "desc_updated"
         size: 1
         image:
           name: {{image_name}}
@@ -510,7 +508,6 @@
   CinderVolumes.create_snapshot_and_attach_volume:
     -
       args:
-        volume_type: false
         size:
           min: 1
           max: 1
@@ -534,7 +531,7 @@
 
     -
       args:
-        volume_type: true
+        volume_type: "test"
         size:
           min: 1
           max: 1
@@ -552,6 +549,8 @@
           flavor:
             name: {{flavor_name}}
           servers_per_tenant: 1
+        volume_types:
+          - "test"
       sla:
         failure_rate:
           max: 0

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

@@ -19,6 +19,7 @@ from oslo_config import cfg
 
 from rally import exceptions
 from rally.plugins.openstack import scenario
+from rally.plugins.openstack.services.storage import block
 from rally.plugins.openstack.wrappers import cinder as cinder_wrapper
 from rally.plugins.openstack.wrappers import glance as glance_wrapper
 from rally.task import atomic
@@ -57,6 +58,23 @@ benchmark_group = cfg.OptGroup(name="benchmark", title="benchmark options")
 CONF.register_opts(CINDER_BENCHMARK_OPTS, group=benchmark_group)
 
 
+class CinderBasic(scenario.OpenStackScenario):
+    def __init__(self, context=None, admin_clients=None, clients=None):
+        super(CinderBasic, self).__init__(context, admin_clients, clients)
+        if hasattr(self, "_admin_clients"):
+            self.admin_cinder = block.BlockStorage(
+                self._admin_clients, name_generator=self.generate_random_name,
+                atomic_inst=self.atomic_actions())
+        if hasattr(self, "_clients"):
+            self.cinder = block.BlockStorage(
+                self._clients, name_generator=self.generate_random_name,
+                atomic_inst=self.atomic_actions())
+
+    def get_random_server(self):
+        server_id = random.choice(self.context["tenant"]["servers"])
+        return self.clients("nova").servers.get(server_id)
+
+
 class CinderScenario(scenario.OpenStackScenario):
     """Base class for Cinder scenarios with basic atomic actions."""
 

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

@@ -22,13 +22,17 @@ from rally.task import validation
 
 
 @validation.number("size", minval=1, integer_only=True)
+@validation.restricted_parameters(["name", "display_name"],
+                                  subdict="create_volume_kwargs")
+@validation.restricted_parameters("name",
+                                  subdict="create_backup_kwargs")
 @validation.required_cinder_services("cinder-backup")
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumeBackups."
                     "create_incremental_volume_backup")
-class CreateIncrementalVolumeBackup(cinder_utils.CinderScenario):
+class CreateIncrementalVolumeBackup(cinder_utils.CinderBasic):
     def run(self, size, do_delete=True, create_volume_kwargs=None,
             create_backup_kwargs=None):
         """Create a incremental volume backup.
@@ -45,12 +49,12 @@ class CreateIncrementalVolumeBackup(cinder_utils.CinderScenario):
         create_volume_kwargs = create_volume_kwargs or {}
         create_backup_kwargs = create_backup_kwargs or {}
 
-        volume = self._create_volume(size, **create_volume_kwargs)
+        volume = self.cinder.create_volume(size, **create_volume_kwargs)
-        backup1 = self._create_backup(volume.id, **create_backup_kwargs)
+        backup1 = self.cinder.create_backup(volume.id, **create_backup_kwargs)
 
-        backup2 = self._create_backup(volume.id, incremental=True)
+        backup2 = self.cinder.create_backup(volume.id, incremental=True)
 
         if do_delete:
-            self._delete_backup(backup2)
+            self.cinder.delete_backup(backup2)
-            self._delete_backup(backup1)
+            self.cinder.delete_backup(backup1)
-            self._delete_volume(volume)
+            self.cinder.delete_volume(volume)

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

@@ -23,11 +23,12 @@ from rally.task import validation
 """Scenarios for Cinder Volume Type."""
 
 
+@validation.restricted_parameters("name")
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(admin=True)
 @scenario.configure(context={"admin_cleanup": ["cinder"]},
                     name="CinderVolumeTypes.create_and_delete_volume_type")
-class CreateAndDeleteVolumeType(cinder_utils.CinderScenario):
+class CreateAndDeleteVolumeType(cinder_utils.CinderBasic):
 
     def run(self, **kwargs):
         """Create and delete a volume Type.
@@ -35,15 +36,16 @@ class CreateAndDeleteVolumeType(cinder_utils.CinderScenario):
         :param kwargs: Optional parameters used during volume
                        type creation.
         """
-        volume_type = self._create_volume_type(**kwargs)
+        volume_type = self.admin_cinder.create_volume_type(**kwargs)
-        self._delete_volume_type(volume_type)
+        self.admin_cinder.delete_volume_type(volume_type)
 
 
+@validation.restricted_parameters("name")
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(admin=True)
 @scenario.configure(context={"admin_cleanup": ["cinder"]},
                     name="CinderVolumeTypes.create_and_get_volume_type")
-class CreateAndGetVolumeType(cinder_utils.CinderScenario):
+class CreateAndGetVolumeType(cinder_utils.CinderBasic):
 
     def run(self, **kwargs):
         """Create a volume Type, then get the details of the type.
@@ -51,16 +53,17 @@ class CreateAndGetVolumeType(cinder_utils.CinderScenario):
         :param kwargs: Optional parameters used during volume
                        type creation.
         """
-        volume_type = self._create_volume_type(**kwargs)
+        volume_type = self.admin_cinder.create_volume_type(**kwargs)
-        self._get_volume_type(volume_type)
+        self.admin_cinder.get_volume_type(volume_type)
 
 
+@validation.restricted_parameters("name")
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(admin=True)
 @scenario.configure(context={"admin_cleanup": ["cinder"]},
                     name="CinderVolumeTypes.create_volume_type"
                          "_and_encryption_type")
-class CreateVolumeTypeAndEncryptionType(cinder_utils.CinderScenario):
+class CreateVolumeTypeAndEncryptionType(cinder_utils.CinderBasic):
 
     def run(self, specs, **kwargs):
         """Create encryption type
@@ -72,16 +75,18 @@ class CreateVolumeTypeAndEncryptionType(cinder_utils.CinderScenario):
         :param kwargs: Optional parameters used during volume
                        type creation.
         """
-        volume_type = self._create_volume_type(**kwargs)
+        volume_type = self.admin_cinder.create_volume_type(**kwargs)
-        self._create_encryption_type(volume_type, specs)
+        self.admin_cinder.create_encryption_type(volume_type,
+                                                 specs=specs)
 
 
+@validation.restricted_parameters("name")
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(admin=True)
 @scenario.configure(context={"admin_cleanup": ["cinder"]},
                     name="CinderVolumeTypes.create_and_list_"
                          "encryption_type")
-class CreateAndListEncryptionType(cinder_utils.CinderScenario):
+class CreateAndListEncryptionType(cinder_utils.CinderBasic):
 
     def run(self, specs, search_opts=None, **kwargs):
         """Create and list encryption type
@@ -95,16 +100,18 @@ class CreateAndListEncryptionType(cinder_utils.CinderScenario):
         :param kwargs: Optional parameters used during volume
                        type creation.
         """
-        volume_type = self._create_volume_type(**kwargs)
+        volume_type = self.admin_cinder.create_volume_type(**kwargs)
-        self._create_encryption_type(volume_type, specs)
+        self.admin_cinder.create_encryption_type(volume_type,
-        self._list_encryption_type(search_opts)
+                                                 specs=specs)
+        self.admin_cinder.list_encryption_type(search_opts)
 
 
+@validation.restricted_parameters("name")
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(admin=True)
 @scenario.configure(context={"admin_cleanup": ["cinder"]},
                     name="CinderVolumeTypes.create_and_set_volume_type_keys")
-class CreateAndSetVolumeTypeKeys(cinder_utils.CinderScenario):
+class CreateAndSetVolumeTypeKeys(cinder_utils.CinderBasic):
 
     def run(self, volume_type_key, **kwargs):
         """Create and set a volume type's extra specs.
@@ -113,9 +120,9 @@ class CreateAndSetVolumeTypeKeys(cinder_utils.CinderScenario):
         :param kwargs: Optional parameters used during volume
                        type creation.
         """
-        volume_type = self._create_volume_type(**kwargs)
+        volume_type = self.admin_cinder.create_volume_type(**kwargs)
-
+        self.admin_cinder.set_volume_type_keys(volume_type,
-        self._set_volume_type_keys(volume_type, volume_type_key)
+                                               metadata=volume_type_key)
 
 
 @validation.required_services(consts.Service.CINDER)
@@ -124,7 +131,7 @@ class CreateAndSetVolumeTypeKeys(cinder_utils.CinderScenario):
 @scenario.configure(context={"admin_cleanup": ["cinder"]},
                     name="CinderVolumeTypes.create_and_delete_"
                          "encryption_type")
-class CreateAndDeleteEncryptionType(cinder_utils.CinderScenario):
+class CreateAndDeleteEncryptionType(cinder_utils.CinderBasic):
 
     def run(self, create_specs):
         """Create and delete encryption type
@@ -135,5 +142,6 @@ class CreateAndDeleteEncryptionType(cinder_utils.CinderScenario):
         :param create_specs: the encryption type specifications to add
         """
         volume_type = random.choice(self.context["volume_types"])
-        self._create_encryption_type(volume_type["id"], create_specs)
+        self.admin_cinder.create_encryption_type(volume_type["id"],
-        self._delete_encryption_type(volume_type["id"])
+                                                 specs=create_specs)
+        self.admin_cinder.delete_encryption_type(volume_type["id"])

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

@@ -32,14 +32,13 @@ LOG = logging.getLogger(__name__)
 
 
 @types.convert(image={"type": "glance_image"})
+@validation.restricted_parameters(["name", "display_name"])
 @validation.image_exists("image", nullable=True)
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumes.create_and_list_volume")
-class CreateAndListVolume(cinder_utils.CinderScenario,
+class CreateAndListVolume(cinder_utils.CinderBasic):
-                          nova_utils.NovaScenario,
-                          glance_utils.GlanceScenario):
 
     def run(self, size, detailed=True, image=None, **kwargs):
         """Create a volume and list all volumes.
@@ -64,19 +63,18 @@ class CreateAndListVolume(cinder_utils.CinderScenario,
         if image:
             kwargs["imageRef"] = image
 
-        self._create_volume(size, **kwargs)
+        self.cinder.create_volume(size, **kwargs)
-        self._list_volumes(detailed)
+        self.cinder.list_volumes(detailed)
 
 
 @types.convert(image={"type": "glance_image"})
+@validation.restricted_parameters(["name", "display_name"])
 @validation.image_exists("image", nullable=True)
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumes.create_and_get_volume")
-class CreateAndGetVolume(cinder_utils.CinderScenario,
+class CreateAndGetVolume(cinder_utils.CinderBasic):
-                         nova_utils.NovaScenario,
-                         glance_utils.GlanceScenario):
 
     def run(self, size, image=None, **kwargs):
         """Create a volume and get the volume.
@@ -93,17 +91,15 @@ class CreateAndGetVolume(cinder_utils.CinderScenario,
         if image:
             kwargs["imageRef"] = image
 
-        volume = self._create_volume(size, **kwargs)
+        volume = self.cinder.create_volume(size, **kwargs)
-        self._get_volume(volume.id)
+        self.cinder.get_volume(volume.id)
 
 
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumes.list_volumes")
-class ListVolumes(cinder_utils.CinderScenario,
+class ListVolumes(cinder_utils.CinderBasic):
-                  nova_utils.NovaScenario,
-                  glance_utils.GlanceScenario):
 
     def run(self, detailed=True):
         """List all volumes.
@@ -115,13 +111,13 @@ class ListVolumes(cinder_utils.CinderScenario,
                          should be listed
         """
 
-        self._list_volumes(detailed)
+        self.cinder.list_volumes(detailed)
 
 
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(name="CinderVolumes.list_types")
-class ListTypes(cinder_utils.CinderScenario):
+class ListTypes(cinder_utils.CinderBasic):
 
     def run(self, search_opts=None, is_public=None):
         """List all volume types.
@@ -133,13 +129,13 @@ class ListTypes(cinder_utils.CinderScenario):
         :param is_public: If query public volume type
         """
 
-        self._list_types(search_opts, is_public)
+        self.cinder.list_types(search_opts, is_public=is_public)
 
 
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(name="CinderVolumes.list_transfers")
-class ListTransfers(cinder_utils.CinderScenario):
+class ListTransfers(cinder_utils.CinderBasic):
 
     def run(self, detailed=True, search_opts=None):
         """List all transfers.
@@ -152,18 +148,20 @@ class ListTransfers(cinder_utils.CinderScenario):
         :param search_opts: Search options to filter out volume transfers.
         """
 
-        self._list_transfers(detailed, search_opts)
+        self.cinder.list_transfers(detailed, search_opts=search_opts)
 
 
 @types.convert(image={"type": "glance_image"})
+@validation.restricted_parameters(["name", "display_name"],
+                                  subdict="create_volume_kwargs")
+@validation.restricted_parameters(["name", "display_name"],
+                                  subdict="update_volume_kwargs")
 @validation.image_exists("image", nullable=True)
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumes.create_and_update_volume")
-class CreateAndUpdateVolume(cinder_utils.CinderScenario,
+class CreateAndUpdateVolume(cinder_utils.CinderBasic):
-                            nova_utils.NovaScenario,
-                            glance_utils.GlanceScenario):
 
     def run(self, size, image=None, create_volume_kwargs=None,
             update_volume_kwargs=None):
@@ -173,24 +171,31 @@ class CreateAndUpdateVolume(cinder_utils.CinderScenario,
         :param image: image to be used to create volume
         :param create_volume_kwargs: dict, to be used to create volume
         :param update_volume_kwargs: dict, to be used to update volume
+               update_volume_kwargs["update_name"]=True, if updating the
+               name of volume.
+               update_volume_kwargs["description"]="desp", if updating the
+               description of volume.
         """
         create_volume_kwargs = create_volume_kwargs or {}
         update_volume_kwargs = update_volume_kwargs or {}
         if image:
             create_volume_kwargs["imageRef"] = image
-        volume = self._create_volume(size, **create_volume_kwargs)
+
-        self._update_volume(volume, **update_volume_kwargs)
+        if update_volume_kwargs.pop("update_name", False):
+            update_volume_kwargs["name"] = self.generate_random_name()
+
+        volume = self.cinder.create_volume(size, **create_volume_kwargs)
+        self.cinder.update_volume(volume, **update_volume_kwargs)
 
 
 @types.convert(image={"type": "glance_image"})
+@validation.restricted_parameters(["name", "display_name"])
 @validation.image_exists("image", nullable=True)
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumes.create_and_delete_volume")
-class CreateAndDeleteVolume(cinder_utils.CinderScenario,
+class CreateAndDeleteVolume(cinder_utils.CinderBasic):
-                            nova_utils.NovaScenario,
-                            glance_utils.GlanceScenario):
 
     def run(self, size, image=None, min_sleep=0, max_sleep=0, **kwargs):
         """Create and then delete a volume.
@@ -214,20 +219,19 @@ class CreateAndDeleteVolume(cinder_utils.CinderScenario,
         if image:
             kwargs["imageRef"] = image
 
-        volume = self._create_volume(size, **kwargs)
+        volume = self.cinder.create_volume(size, **kwargs)
         self.sleep_between(min_sleep, max_sleep)
-        self._delete_volume(volume)
+        self.cinder.delete_volume(volume)
 
 
 @types.convert(image={"type": "glance_image"})
+@validation.restricted_parameters(["name", "display_name"])
 @validation.image_exists("image", nullable=True)
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumes.create_volume")
-class CreateVolume(cinder_utils.CinderScenario,
+class CreateVolume(cinder_utils.CinderBasic):
-                   nova_utils.NovaScenario,
-                   glance_utils.GlanceScenario):
 
     def run(self, size, image=None, **kwargs):
         """Create a volume.
@@ -245,7 +249,7 @@ class CreateVolume(cinder_utils.CinderScenario,
         if image:
             kwargs["imageRef"] = image
 
-        self._create_volume(size, **kwargs)
+        self.cinder.create_volume(size, **kwargs)
 
 
 @validation.required_services(consts.Service.CINDER)
@@ -253,9 +257,7 @@ class CreateVolume(cinder_utils.CinderScenario,
 @validation.required_contexts("volumes")
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumes.modify_volume_metadata")
-class ModifyVolumeMetadata(cinder_utils.CinderScenario,
+class ModifyVolumeMetadata(cinder_utils.CinderBasic):
-                           nova_utils.NovaScenario,
-                           glance_utils.GlanceScenario):
 
     def run(self, sets=10, set_size=3, deletes=5, delete_size=3):
         """Modify a volume's metadata.
@@ -279,17 +281,19 @@ class ModifyVolumeMetadata(cinder_utils.CinderScenario,
                  "num_deletes": deletes * delete_size})
 
         volume = random.choice(self.context["tenant"]["volumes"])
-        keys = self._set_metadata(volume["id"], sets, set_size)
+        keys = self.cinder.set_metadata(volume["id"], sets=sets,
-        self._delete_metadata(volume["id"], keys, deletes, delete_size)
+                                        set_size=set_size)
+        self.cinder.delete_metadata(volume["id"], keys=keys,
+                                    deletes=deletes,
+                                    delete_size=delete_size)
 
 
+@validation.restricted_parameters(["name", "display_name"])
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumes.create_and_extend_volume")
-class CreateAndExtendVolume(cinder_utils.CinderScenario,
+class CreateAndExtendVolume(cinder_utils.CinderBasic):
-                            nova_utils.NovaScenario,
-                            glance_utils.GlanceScenario):
 
     def run(self, size, new_size, min_sleep=0, max_sleep=0, **kwargs):
         """Create and extend a volume and then delete it.
@@ -311,20 +315,19 @@ class CreateAndExtendVolume(cinder_utils.CinderScenario,
                           deletion (in seconds)
         :param kwargs: optional args to extend the volume
         """
-        volume = self._create_volume(size, **kwargs)
+        volume = self.cinder.create_volume(size, **kwargs)
-        self._extend_volume(volume, new_size)
+        self.cinder.extend_volume(volume, new_size=new_size)
         self.sleep_between(min_sleep, max_sleep)
-        self._delete_volume(volume)
+        self.cinder.delete_volume(volume)
 
 
+@validation.restricted_parameters(["name", "display_name"])
 @validation.required_services(consts.Service.CINDER)
 @validation.required_contexts("volumes")
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumes.create_from_volume_and_delete_volume")
-class CreateFromVolumeAndDeleteVolume(cinder_utils.CinderScenario,
+class CreateFromVolumeAndDeleteVolume(cinder_utils.CinderBasic):
-                                      nova_utils.NovaScenario,
-                                      glance_utils.GlanceScenario):
 
     def run(self, size, min_sleep=0, max_sleep=0, **kwargs):
         """Create volume from volume and then delete it.
@@ -346,20 +349,19 @@ class CreateFromVolumeAndDeleteVolume(cinder_utils.CinderScenario,
         :param kwargs: optional args to create a volume
         """
         source_vol = random.choice(self.context["tenant"]["volumes"])
-        volume = self._create_volume(size, source_volid=source_vol["id"],
+        volume = self.cinder.create_volume(size, source_volid=source_vol["id"],
-                                     **kwargs)
+                                           **kwargs)
         self.sleep_between(min_sleep, max_sleep)
-        self._delete_volume(volume)
+        self.cinder.delete_volume(volume)
 
 
+@validation.restricted_parameters(["name", "display_name"])
 @validation.required_services(consts.Service.CINDER)
 @validation.required_contexts("volumes")
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumes.create_and_delete_snapshot")
-class CreateAndDeleteSnapshot(cinder_utils.CinderScenario,
+class CreateAndDeleteSnapshot(cinder_utils.CinderBasic):
-                              nova_utils.NovaScenario,
-                              glance_utils.GlanceScenario):
 
     def run(self, force=False, min_sleep=0, max_sleep=0, **kwargs):
         """Create and then delete a volume-snapshot.
@@ -377,21 +379,23 @@ class CreateAndDeleteSnapshot(cinder_utils.CinderScenario,
         :param kwargs: optional args to create a snapshot
         """
         volume = random.choice(self.context["tenant"]["volumes"])
-        snapshot = self._create_snapshot(volume["id"], force=force, **kwargs)
+        snapshot = self.cinder.create_snapshot(volume["id"], force=force,
+                                               **kwargs)
         self.sleep_between(min_sleep, max_sleep)
-        self._delete_snapshot(snapshot)
+        self.cinder.delete_snapshot(snapshot)
 
 
 @types.convert(image={"type": "glance_image"},
                flavor={"type": "nova_flavor"})
+@validation.restricted_parameters(["name", "display_name"],
+                                  subdict="create_volume_params")
 @validation.image_valid_on_flavor("flavor", "image")
 @validation.required_services(consts.Service.NOVA, consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder", "nova"]},
                     name="CinderVolumes.create_and_attach_volume")
-class CreateAndAttachVolume(cinder_utils.CinderScenario,
+class CreateAndAttachVolume(cinder_utils.CinderBasic,
-                            nova_utils.NovaScenario,
+                            nova_utils.NovaScenario):
-                            glance_utils.GlanceScenario):
 
     @logging.log_deprecated_args(
         "Use 'create_vm_params' for additional instance parameters.",
@@ -424,25 +428,25 @@ class CreateAndAttachVolume(cinder_utils.CinderScenario,
         create_vm_params = create_vm_params or kwargs or {}
 
         server = self._boot_server(image, flavor, **create_vm_params)
-        volume = self._create_volume(size, **create_volume_params)
+        volume = self.cinder.create_volume(size, **create_volume_params)
 
         attachment = self._attach_volume(server, volume)
         self._detach_volume(server, volume, attachment)
 
-        self._delete_volume(volume)
+        self.cinder.delete_volume(volume)
         self._delete_server(server)
 
 
+@validation.restricted_parameters(["name", "display_name"])
 @validation.volume_type_exists("volume_type")
 @validation.required_services(consts.Service.NOVA, consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder", "nova"]},
                     name="CinderVolumes.create_snapshot_and_attach_volume")
-class CreateSnapshotAndAttachVolume(cinder_utils.CinderScenario,
+class CreateSnapshotAndAttachVolume(cinder_utils.CinderBasic,
-                                    nova_utils.NovaScenario,
+                                    nova_utils.NovaScenario):
-                                    glance_utils.GlanceScenario):
 
-    def run(self, volume_type=False, size=None, **kwargs):
+    def run(self, volume_type=None, size=None, **kwargs):
         """Create volume, snapshot and attach/detach volume.
 
         :param volume_type: Name of volume type to use
@@ -456,35 +460,30 @@ class CreateSnapshotAndAttachVolume(cinder_utils.CinderScenario,
         if size is None:
             size = {"min": 1, "max": 5}
 
-        if isinstance(volume_type, bool):
+        volume = self.cinder.create_volume(size, volume_type=volume_type)
-            LOG.warning("Selecting a random volume type is deprecated"
+        snapshot = self.cinder.create_snapshot(volume.id, force=False,
-                        "as of Rally 0.7.0")
+                                               **kwargs)
-            volume_types = [None]
-            volume_types_list = self.clients("cinder").volume_types.list()
-            for s in volume_types_list:
-                volume_types.append(s.name)
-            volume_type = random.choice(volume_types)
-
-        volume = self._create_volume(size, volume_type=volume_type)
-        snapshot = self._create_snapshot(volume.id, False, **kwargs)
 
         server = self.get_random_server()
 
         attachment = self._attach_volume(server, volume)
         self._detach_volume(server, volume, attachment)
 
-        self._delete_snapshot(snapshot)
+        self.cinder.delete_snapshot(snapshot)
-        self._delete_volume(volume)
+        self.cinder.delete_volume(volume)
 
 
+@validation.restricted_parameters(["name", "display_name"],
+                                  subdict="create_volume_kwargs")
+@validation.restricted_parameters(["name", "display_name"],
+                                  subdict="create_snapshot_kwargs")
 @validation.required_services(consts.Service.NOVA, consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder", "nova"]},
                     name="CinderVolumes.create_nested_snapshots"
                          "_and_attach_volume")
-class CreateNestedSnapshotsAndAttachVolume(cinder_utils.CinderScenario,
+class CreateNestedSnapshotsAndAttachVolume(cinder_utils.CinderBasic,
-                                           nova_utils.NovaScenario,
+                                           nova_utils.NovaScenario):
-                                           glance_utils.GlanceScenario):
 
     @logging.log_deprecated_args(
         "Use 'create_snapshot_kwargs' for additional snapshot kwargs.",
@@ -521,16 +520,16 @@ class CreateNestedSnapshotsAndAttachVolume(cinder_utils.CinderScenario,
         create_snapshot_kwargs = create_snapshot_kwargs or kwargs or {}
         server = self.get_random_server()
 
-        source_vol = self._create_volume(size, **create_volume_kwargs)
+        source_vol = self.cinder.create_volume(size, **create_volume_kwargs)
-        snapshot = self._create_snapshot(source_vol.id, False,
+        snapshot = self.cinder.create_snapshot(source_vol.id, force=False,
-                                         **create_snapshot_kwargs)
+                                               **create_snapshot_kwargs)
         attachment = self._attach_volume(server, source_vol)
 
         nes_objs = [(server, source_vol, snapshot, attachment)]
         for i in range(nested_level - 1):
-            volume = self._create_volume(size, snapshot_id=snapshot.id)
+            volume = self.cinder.create_volume(size, snapshot_id=snapshot.id)
-            snapshot = self._create_snapshot(volume.id, False,
+            snapshot = self.cinder.create_snapshot(volume.id, force=False,
-                                             **create_snapshot_kwargs)
+                                                   **create_snapshot_kwargs)
             server = self.get_random_server()
             attachment = self._attach_volume(server, volume)
 
@@ -539,16 +538,17 @@ class CreateNestedSnapshotsAndAttachVolume(cinder_utils.CinderScenario,
         nes_objs.reverse()
         for server, volume, snapshot, attachment in nes_objs:
             self._detach_volume(server, volume, attachment)
-            self._delete_snapshot(snapshot)
+            self.cinder.delete_snapshot(snapshot)
-            self._delete_volume(volume)
+            self.cinder.delete_volume(volume)
 
 
+@validation.restricted_parameters(["name", "display_name"])
 @validation.required_services(consts.Service.CINDER)
 @validation.required_contexts("volumes")
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumes.create_and_list_snapshots")
-class CreateAndListSnapshots(cinder_utils.CinderScenario,
+class CreateAndListSnapshots(cinder_utils.CinderBasic,
                              nova_utils.NovaScenario,
                              glance_utils.GlanceScenario):
 
@@ -562,18 +562,18 @@ class CreateAndListSnapshots(cinder_utils.CinderScenario,
         :param kwargs: optional args to create a snapshot
         """
         volume = random.choice(self.context["tenant"]["volumes"])
-        self._create_snapshot(volume["id"], force=force, **kwargs)
+        self.cinder.create_snapshot(volume["id"], force=force, **kwargs)
-        self._list_snapshots(detailed)
+        self.cinder.list_snapshots(detailed)
 
 
 @types.convert(image={"type": "glance_image"})
+@validation.restricted_parameters(["name", "display_name"])
 @validation.required_services(consts.Service.CINDER, consts.Service.GLANCE)
 @validation.required_openstack(users=True)
 @validation.required_parameters("size")
 @scenario.configure(context={"cleanup": ["cinder", "glance"]},
                     name="CinderVolumes.create_and_upload_volume_to_image")
-class CreateAndUploadVolumeToImage(cinder_utils.CinderScenario,
+class CreateAndUploadVolumeToImage(cinder_utils.CinderBasic,
-                                   nova_utils.NovaScenario,
                                    glance_utils.GlanceScenario):
 
     def run(self, size, image=None, force=False, container_format="bare",
@@ -594,23 +594,25 @@ class CreateAndUploadVolumeToImage(cinder_utils.CinderScenario,
         """
         if image:
             kwargs["imageRef"] = image
-        volume = self._create_volume(size, **kwargs)
+        volume = self.cinder.create_volume(size, **kwargs)
-        image = self._upload_volume_to_image(volume, force, container_format,
+        image = self.cinder.upload_volume_to_image(
-                                             disk_format)
+            volume, force=force, container_format=container_format,
+            disk_format=disk_format)
 
         if do_delete:
-            self._delete_volume(volume)
+            self.cinder.delete_volume(volume)
             self._delete_image(image)
 
 
+@validation.restricted_parameters(["name", "display_name"],
+                                  subdict="create_volume_kwargs")
+@validation.restricted_parameters("name", subdict="create_backup_kwargs")
 @validation.required_cinder_services("cinder-backup")
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumes.create_volume_backup")
-class CreateVolumeBackup(cinder_utils.CinderScenario,
+class CreateVolumeBackup(cinder_utils.CinderBasic):
-                         nova_utils.NovaScenario,
-                         glance_utils.GlanceScenario):
 
     def run(self, size, do_delete=True, create_volume_kwargs=None,
             create_backup_kwargs=None):
@@ -625,22 +627,23 @@ class CreateVolumeBackup(cinder_utils.CinderScenario,
         create_volume_kwargs = create_volume_kwargs or {}
         create_backup_kwargs = create_backup_kwargs or {}
 
-        volume = self._create_volume(size, **create_volume_kwargs)
+        volume = self.cinder.create_volume(size, **create_volume_kwargs)
-        backup = self._create_backup(volume.id, **create_backup_kwargs)
+        backup = self.cinder.create_backup(volume.id, **create_backup_kwargs)
 
         if do_delete:
-            self._delete_volume(volume)
+            self.cinder.delete_volume(volume)
-            self._delete_backup(backup)
+            self.cinder.delete_backup(backup)
 
 
+@validation.restricted_parameters(["name", "display_name"],
+                                  subdict="create_volume_kwargs")
+@validation.restricted_parameters("name", subdict="create_backup_kwargs")
 @validation.required_cinder_services("cinder-backup")
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumes.create_and_restore_volume_backup")
-class CreateAndRestoreVolumeBackup(cinder_utils.CinderScenario,
+class CreateAndRestoreVolumeBackup(cinder_utils.CinderBasic):
-                                   nova_utils.NovaScenario,
-                                   glance_utils.GlanceScenario):
 
     def run(self, size, do_delete=True, create_volume_kwargs=None,
             create_backup_kwargs=None):
@@ -655,23 +658,24 @@ class CreateAndRestoreVolumeBackup(cinder_utils.CinderScenario,
         create_volume_kwargs = create_volume_kwargs or {}
         create_backup_kwargs = create_backup_kwargs or {}
 
-        volume = self._create_volume(size, **create_volume_kwargs)
+        volume = self.cinder.create_volume(size, **create_volume_kwargs)
-        backup = self._create_backup(volume.id, **create_backup_kwargs)
+        backup = self.cinder.create_backup(volume.id, **create_backup_kwargs)
-        self._restore_backup(backup.id)
+        self.cinder.restore_backup(backup.id)
 
         if do_delete:
-            self._delete_volume(volume)
+            self.cinder.delete_volume(volume)
-            self._delete_backup(backup)
+            self.cinder.delete_backup(backup)
 
 
+@validation.restricted_parameters(["name", "display_name"],
+                                  subdict="create_volume_kwargs")
+@validation.restricted_parameters("name", subdict="create_backup_kwargs")
 @validation.required_cinder_services("cinder-backup")
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumes.create_and_list_volume_backups")
-class CreateAndListVolumeBackups(cinder_utils.CinderScenario,
+class CreateAndListVolumeBackups(cinder_utils.CinderBasic):
-                                 nova_utils.NovaScenario,
-                                 glance_utils.GlanceScenario):
 
     def run(self, size, detailed=True, do_delete=True,
             create_volume_kwargs=None, create_backup_kwargs=None):
@@ -687,24 +691,23 @@ class CreateAndListVolumeBackups(cinder_utils.CinderScenario,
         create_volume_kwargs = create_volume_kwargs or {}
         create_backup_kwargs = create_backup_kwargs or {}
 
-        volume = self._create_volume(size, **create_volume_kwargs)
+        volume = self.cinder.create_volume(size, **create_volume_kwargs)
-        backup = self._create_backup(volume.id, **create_backup_kwargs)
+        backup = self.cinder.create_backup(volume.id, **create_backup_kwargs)
-        self._list_backups(detailed)
+        self.cinder.list_backups(detailed)
 
         if do_delete:
-            self._delete_volume(volume)
+            self.cinder.delete_volume(volume)
-            self._delete_backup(backup)
+            self.cinder.delete_backup(backup)
 
 
 @types.convert(image={"type": "glance_image"})
+@validation.restricted_parameters(["name", "display_name"])
 @validation.image_exists("image", nullable=True)
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumes.create_volume_and_clone")
-class CreateVolumeAndClone(cinder_utils.CinderScenario,
+class CreateVolumeAndClone(cinder_utils.CinderBasic):
-                           nova_utils.NovaScenario,
-                           glance_utils.GlanceScenario):
 
     def run(self, size, image=None, nested_level=1, **kwargs):
         """Create a volume, then clone it to another volume.
@@ -728,24 +731,25 @@ class CreateVolumeAndClone(cinder_utils.CinderScenario,
         if image:
             kwargs["imageRef"] = image
 
-        source_vol = self._create_volume(size, **kwargs)
+        source_vol = self.cinder.create_volume(size, **kwargs)
 
         kwargs.pop("imageRef", None)
         for i in range(nested_level):
             with atomic.ActionTimer(self, "cinder.clone_volume"):
-                source_vol = self._create_volume(source_vol.size,
+                source_vol = self.cinder.create_volume(
-                                                 source_volid=source_vol.id,
+                    source_vol.size, source_volid=source_vol.id,
-                                                 atomic_action=False, **kwargs)
+                    **kwargs)
 
 
+@validation.restricted_parameters(["name", "display_name"])
+@validation.restricted_parameters(["name", "display_name"],
+                                  subdict="create_snapshot_kwargs")
 @validation.required_services(consts.Service.CINDER)
 @validation.required_contexts("volumes")
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumes.create_volume_from_snapshot")
-class CreateVolumeFromSnapshot(cinder_utils.CinderScenario,
+class CreateVolumeFromSnapshot(cinder_utils.CinderBasic):
-                               nova_utils.NovaScenario,
-                               glance_utils.GlanceScenario):
 
     def run(self, do_delete=True, create_snapshot_kwargs=None, **kwargs):
         """Create a volume-snapshot, then create a volume from this snapshot.
@@ -758,26 +762,26 @@ class CreateVolumeFromSnapshot(cinder_utils.CinderScenario,
         create_snapshot_kwargs = create_snapshot_kwargs or {}
         src_volume = random.choice(self.context["tenant"]["volumes"])
 
-        snapshot = self._create_snapshot(src_volume["id"],
+        snapshot = self.cinder.create_snapshot(src_volume["id"],
-                                         **create_snapshot_kwargs)
+                                               **create_snapshot_kwargs)
-        volume = self._create_volume(src_volume["size"],
+        volume = self.cinder.create_volume(src_volume["size"],
-                                     snapshot_id=snapshot.id,
+                                           snapshot_id=snapshot.id,
-                                     **kwargs)
+                                           **kwargs)
 
         if do_delete:
-            self._delete_snapshot(snapshot)
+            self.cinder.delete_snapshot(snapshot)
-            self._delete_volume(volume)
+            self.cinder.delete_volume(volume)
 
 
 @types.convert(image={"type": "glance_image"})
+@validation.restricted_parameters(["name", "display_name"])
 @validation.image_exists("image", nullable=True)
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumes.create_volume_"
                     "and_update_readonly_flag")
-class CreateVolumeAndUpdateReadonlyFlag(cinder_utils.CinderScenario,
+class CreateVolumeAndUpdateReadonlyFlag(cinder_utils.CinderBasic):
-                                        glance_utils.GlanceScenario):
 
     def run(self, size, image=None, read_only=True, **kwargs):
         """Create a volume and then update its readonly flag.
@@ -790,18 +794,18 @@ class CreateVolumeAndUpdateReadonlyFlag(cinder_utils.CinderScenario,
         """
         if image:
             kwargs["imageRef"] = image
-        volume = self._create_volume(size, **kwargs)
+        volume = self.cinder.create_volume(size, **kwargs)
-        self._update_readonly_flag(volume.id, read_only)
+        self.cinder.update_readonly_flag(volume.id, read_only=read_only)
 
 
 @types.convert(image={"type": "glance_image"})
+@validation.restricted_parameters(["name", "display_name"])
 @validation.image_exists("image", nullable=True)
 @validation.required_services(consts.Service.CINDER)
 @validation.required_openstack(users=True)
 @scenario.configure(context={"cleanup": ["cinder"]},
                     name="CinderVolumes.create_and_accept_transfer")
-class CreateAndAcceptTransfer(cinder_utils.CinderScenario,
+class CreateAndAcceptTransfer(cinder_utils.CinderBasic):
-                              glance_utils.GlanceScenario):
 
     def run(self, size, image=None, **kwargs):
         """Create a volume transfer, then accept it
@@ -814,6 +818,6 @@ class CreateAndAcceptTransfer(cinder_utils.CinderScenario,
         """
         if image:
             kwargs["imageRef"] = image
-        volume = self._create_volume(size, **kwargs)
+        volume = self.cinder.create_volume(size, **kwargs)
-        transfer = self._transfer_create(volume.id)
+        transfer = self.cinder.transfer_create(volume.id)
-        self._transfer_accept(transfer.id, transfer.auth_key)
+        self.cinder.transfer_accept(transfer.id, auth_key=transfer.auth_key)

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

@@ -19,6 +19,7 @@ from oslo_config import cfg
 
 from rally import exceptions
 from rally.plugins.openstack import scenario
+from rally.plugins.openstack.scenarios.cinder import utils as cinder_utils
 from rally.plugins.openstack.wrappers import glance as glance_wrapper
 from rally.plugins.openstack.wrappers import network as network_wrapper
 from rally.task import atomic
@@ -713,6 +714,10 @@ class NovaScenario(scenario.OpenStackScenario):
                 CONF.benchmark.nova_server_resize_revert_poll_interval)
         )
 
+    def _update_volume_resource(self, resource):
+        cinder_service = cinder_utils.CinderBasic(self.context)
+        return cinder_service.cinder.get_volume(resource.id)
+
     @atomic.action_timer("nova.attach_volume")
     def _attach_volume(self, server, volume, device=None):
         server_id = server.id
@@ -722,7 +727,7 @@ class NovaScenario(scenario.OpenStackScenario):
         utils.wait_for_status(
             volume,
             ready_statuses=["in-use"],
-            update_resource=utils.get_from_manager(),
+            update_resource=self._update_volume_resource,
             timeout=CONF.benchmark.nova_server_resize_revert_timeout,
             check_interval=(
                 CONF.benchmark.nova_server_resize_revert_poll_interval)
@@ -741,7 +746,7 @@ class NovaScenario(scenario.OpenStackScenario):
         utils.wait_for_status(
             volume,
             ready_statuses=["available"],
-            update_resource=utils.get_from_manager(),
+            update_resource=self._update_volume_resource,
             timeout=CONF.benchmark.nova_detach_volume_timeout,
             check_interval=CONF.benchmark.nova_detach_volume_poll_interval
         )

rally/plugins/openstack/services/storage/block.py

@@ -43,13 +43,16 @@ CONF = cfg.CONF
 benchmark_group = cfg.OptGroup(name="benchmark", title="benchmark options")
 CONF.register_opts(CINDER_BENCHMARK_OPTS, group=benchmark_group)
 
-Volume = collections.namedtuple("Volume", ["id", "name", "size"])
+Volume = collections.namedtuple("Volume", ["id", "name", "size", "status"])
 VolumeSnapshot = collections.namedtuple("VolumeSnapshot", ["id", "name",
-                                                           "volume_id"])
+                                                           "volume_id",
+                                                           "status"])
 VolumeBackup = collections.namedtuple("VolumeBackup", ["id", "name",
-                                                       "volume_id"])
+                                                       "volume_id",
+                                                       "status"])
 VolumeTransfer = collections.namedtuple("VolumeTransfer", ["id", "name",
-                                                           "volume_id"])
+                                                           "volume_id",
+                                                           "auth_key"])
 VolumeEncryptionType = collections.namedtuple("VolumeEncryptionType",
                                               ["id", "volume_type_id"])
 
@@ -305,6 +308,15 @@ class BlockStorage(service.UnifiedOpenStackService):
                                              description=description,
                                              is_public=is_public)
 
+    @service.should_be_overridden
+    def get_volume_type(self, volume_type):
+        """get details of volume_type.
+
+        :param volume_type: The ID of the :class:`VolumeType` to get
+        :returns: :class:`VolumeType`
+        """
+        return self._impl.get_volume_type(volume_type)
+
     @service.should_be_overridden
     def delete_volume_type(self, volume_type):
         """delete a volume type.

rally/plugins/openstack/services/storage/cinder_common.py

@@ -28,11 +28,30 @@ class CinderMixin(object):
     def _get_client(self):
         return self._clients.cinder(self.version)
 
+    def _update_resource(self, resource):
+        try:
+            manager = getattr(resource, "manager", None)
+            if manager:
+                res = manager.get(resource.id)
+            else:
+                if isinstance(resource, block.Volume):
+                    attr = "volumes"
+                elif isinstance(resource, block.VolumeSnapshot):
+                    attr = "volume_snapshots"
+                elif isinstance(resource, block.VolumeBackup):
+                    attr = "backups"
+                res = getattr(self._get_client(), attr).get(resource.id)
+        except Exception as e:
+            if getattr(e, "code", getattr(e, "http_status", 400)) == 404:
+                raise exceptions.GetResourceNotFound(resource=resource)
+            raise exceptions.GetResourceFailure(resource=resource, err=e)
+        return res
+
     def _wait_available_volume(self, volume):
         return bench_utils.wait_for_status(
             volume,
             ready_statuses=["available"],
-            update_resource=bench_utils.get_from_manager(),
+            update_resource=self._update_resource,
             timeout=CONF.benchmark.cinder_volume_create_timeout,
             check_interval=CONF.benchmark.cinder_volume_create_poll_interval
         )
@@ -58,7 +77,7 @@ class CinderMixin(object):
                 volume,
                 ready_statuses=["deleted"],
                 check_deletion=True,
-                update_resource=bench_utils.get_from_manager(),
+                update_resource=self._update_resource,
                 timeout=CONF.benchmark.cinder_volume_delete_timeout,
                 check_interval=(CONF.benchmark
                                 .cinder_volume_delete_poll_interval)
@@ -72,7 +91,7 @@ class CinderMixin(object):
         aname = "cinder_v%s.extend_volume" % self.version
         with atomic.ActionTimer(self, aname):
             self._get_client().volumes.extend(volume, new_size)
-            self._wait_available_volume(volume)
+            return self._wait_available_volume(volume)
 
     def list_snapshots(self, detailed=True):
         """Get a list of all snapshots."""
@@ -199,7 +218,7 @@ class CinderMixin(object):
                 snapshot,
                 ready_statuses=["deleted"],
                 check_deletion=True,
-                update_resource=bench_utils.get_from_manager(),
+                update_resource=self._update_resource,
                 timeout=CONF.benchmark.cinder_volume_delete_timeout,
                 check_interval=(CONF.benchmark
                                 .cinder_volume_delete_poll_interval)
@@ -219,7 +238,7 @@ class CinderMixin(object):
                 backup,
                 ready_statuses=["deleted"],
                 check_deletion=True,
-                update_resource=bench_utils.get_from_manager(),
+                update_resource=self._update_resource,
                 timeout=CONF.benchmark.cinder_volume_delete_timeout,
                 check_interval=(CONF.benchmark
                                 .cinder_volume_delete_poll_interval)
@@ -259,6 +278,16 @@ class CinderMixin(object):
         with atomic.ActionTimer(self, aname):
             return self._get_client().transfers.list(detailed, search_opts)
 
+    def get_volume_type(self, volume_type):
+        """get details of volume_type.
+
+        :param volume_type: The ID of the :class:`VolumeType` to get
+        :returns: :class:`VolumeType`
+        """
+        aname = "cinder_v%s.get_volume_type" % self.version
+        with atomic.ActionTimer(self, aname):
+            return self._get_client().volume_types.get(volume_type)
+
     def delete_volume_type(self, volume_type):
         """delete a volume type.
 
@@ -348,12 +377,15 @@ class UnifiedCinderMixin(object):
     @staticmethod
     def _unify_backup(backup):
         return block.VolumeBackup(id=backup.id, name=backup.name,
-                                  volume_id=backup.volume_id)
+                                  volume_id=backup.volume_id,
+                                  status=backup.status)
 
     @staticmethod
     def _unify_transfer(transfer):
+        auth_key = transfer.auth_key if hasattr(transfer, "auth_key") else None
         return block.VolumeTransfer(id=transfer.id, name=transfer.name,
-                                    volume_id=transfer.volume_id)
+                                    volume_id=transfer.volume_id,
+                                    auth_key=auth_key)
 
     @staticmethod
     def _unify_encryption_type(encryption_type):
@@ -431,17 +463,6 @@ class UnifiedCinderMixin(object):
         """Delete a volume backup."""
         self._impl.delete_backup(backup)
 
-    def restore_backup(self, backup_id, volume_id=None):
-        """Restore the given backup.
-
-        :param backup_id: The ID of the backup to restore.
-        :param volume_id: The ID of the volume to restore the backup to.
-
-        :returns: Return the restored backup.
-        """
-        return self._unify_backup(self._impl.restore_backup(
-            backup_id, volume_id=volume_id))
-
     def list_backups(self, detailed=True):
         """Return user volume backups list."""
         return [self._unify_backup(backup)
@@ -459,6 +480,14 @@ class UnifiedCinderMixin(object):
                 for transfer in self._impl.list_transfers(
                     detailed=detailed, search_opts=search_opts)]
 
+    def get_volume_type(self, volume_type):
+        """get details of volume_type.
+
+        :param volume_type: The ID of the :class:`VolumeType` to get
+        :returns: :class:`VolumeType`
+        """
+        return self._impl.get_volume_type(volume_type)
+
     def delete_volume_type(self, volume_type):
         """delete a volume type.
 

rally/plugins/openstack/services/storage/cinder_v1.py

@@ -81,10 +81,14 @@ class CinderV1Service(service.Service, cinder_common.CinderMixin):
 
         :returns: The updated volume.
         """
-        display_name = display_name or self.generate_random_name()
+        kwargs = {}
-        return self._get_client().volumes.update(
+        if display_name is not None:
-            volume_id, display_name=display_name,
+            kwargs["display_name"] = display_name
-            display_description=display_description)
+        if display_description is not None:
+            kwargs["display_description"] = display_description
+        updated_volume = self._get_client().volumes.update(
+            volume_id, **kwargs)
+        return updated_volume["volume"]
 
     @atomic.action_timer("cinder_v1.list_types")
     def list_types(self, search_opts=None):
@@ -151,13 +155,18 @@ class UnifiedCinderV1Service(cinder_common.UnifiedCinderMixin,
 
     @staticmethod
     def _unify_volume(volume):
-        return block.Volume(id=volume.id, name=volume.display_name,
+        if isinstance(volume, dict):
-                            size=volume.size)
+            return block.Volume(id=volume["id"], name=volume["display_name"],
+                                size=volume["size"], status=volume["status"])
+        else:
+            return block.Volume(id=volume.id, name=volume.display_name,
+                                size=volume.size, status=volume.status)
 
     @staticmethod
     def _unify_snapshot(snapshot):
         return block.VolumeSnapshot(id=snapshot.id, name=snapshot.display_name,
-                                    volume_id=snapshot.volume_id)
+                                    volume_id=snapshot.volume_id,
+                                    status=snapshot.status)
 
     def create_volume(self, size, consistencygroup_id=None,
                       group_id=None, snapshot_id=None, source_volid=None,
@@ -291,3 +300,14 @@ class UnifiedCinderV1Service(cinder_common.UnifiedCinderMixin,
         :returns: Return the created volume type.
         """
         return self._impl.create_volume_type(name=name)
+
+    def restore_backup(self, backup_id, volume_id=None):
+        """Restore the given backup.
+
+        :param backup_id: The ID of the backup to restore.
+        :param volume_id: The ID of the volume to restore the backup to.
+
+        :returns: Return the restored backup.
+        """
+        return self._unify_volume(self._impl.restore_backup(
+            backup_id, volume_id=volume_id))

rally/plugins/openstack/services/storage/cinder_v2.py

@@ -92,9 +92,14 @@ class CinderV2Service(service.Service, cinder_common.CinderMixin):
 
         :returns: The updated volume.
         """
-        return self._get_client().volumes.update(
+        kwargs = {}
-            volume_id, name=name or self.generate_random_name(),
+        if name is not None:
-            description=description)
+            kwargs["name"] = name
+        if description is not None:
+            kwargs["description"] = description
+        updated_volume = self._get_client().volumes.update(
+            volume_id, **kwargs)
+        return updated_volume["volume"]
 
     @atomic.action_timer("cinder_v2.list_types")
     def list_types(self, search_opts=None, is_public=None):
@@ -177,13 +182,18 @@ class UnifiedCinderV2Service(cinder_common.UnifiedCinderMixin,
 
     @staticmethod
     def _unify_volume(volume):
-        return block.Volume(id=volume.id, name=volume.name,
+        if isinstance(volume, dict):
-                            size=volume.size)
+            return block.Volume(id=volume["id"], name=volume["name"],
+                                size=volume["size"], status=volume["status"])
+        else:
+            return block.Volume(id=volume.id, name=volume.name,
+                                size=volume.size, status=volume.status)
 
     @staticmethod
     def _unify_snapshot(snapshot):
         return block.VolumeSnapshot(id=snapshot.id, name=snapshot.name,
-                                    volume_id=snapshot.volume_id)
+                                    volume_id=snapshot.volume_id,
+                                    status=snapshot.status)
 
     def create_volume(self, size, consistencygroup_id=None,
                       group_id=None, snapshot_id=None, source_volid=None,
@@ -321,3 +331,14 @@ class UnifiedCinderV2Service(cinder_common.UnifiedCinderMixin,
         return self._impl.create_volume_type(name=name,
                                              description=description,
                                              is_public=is_public)
+
+    def restore_backup(self, backup_id, volume_id=None):
+        """Restore the given backup.
+
+        :param backup_id: The ID of the backup to restore.
+        :param volume_id: The ID of the volume to restore the backup to.
+
+        :returns: Return the restored backup.
+        """
+        return self._unify_volume(self._impl.restore_backup(
+            backup_id, volume_id=volume_id))

samples/tasks/scenarios/cinder/create-and-update-volume.json

@@ -4,8 +4,7 @@
             "args": {
                 "create_volume_kwargs": {},
                 "update_volume_kwargs": {
-                    "display_name": "name_updated",
+                    "description": "desc_updated"
-                    "display_description": "desc_updated"
                  },
                 "size": 1
             },

samples/tasks/scenarios/cinder/create-and-update-volume.yaml

@@ -3,8 +3,7 @@
     -
       args:
         update_volume_kwargs:
-           display_name: "name_updated"
+           description: "desc_updated"
-           display_description: "desc_updated"
         create_volume_kwargs: {}
         size: 1
       runner:

samples/tasks/scenarios/cinder/create-snapshot-and-attach-volume.json

@@ -3,7 +3,6 @@
     "CinderVolumes.create_snapshot_and_attach_volume": [
         {
             "args": {
-                "volume_type": false,
                 "size": {
                     "min": 1,
                     "max": 5
@@ -32,7 +31,7 @@
         },
         {
             "args": {
-                "volume_type": true,
+                "volume_type": "test",
                 "size": {
                     "min": 1,
                     "max": 5
@@ -56,7 +55,8 @@
                         "name": "{{flavor_name}}"
                     },
                     "servers_per_tenant": 2
-                }
+                },
+                "volume_types": ["test"]
             }
         }
 

samples/tasks/scenarios/cinder/create-snapshot-and-attach-volume.yaml

@@ -3,7 +3,6 @@
   CinderVolumes.create_snapshot_and_attach_volume:
     -
       args:
-          volume_type: false
           size:
               min: 1
               max: 5
@@ -23,7 +22,7 @@
           servers_per_tenant: 2
     -
       args:
-          volume_type: true
+          volume_type: "test"
           size:
               min: 1
               max: 5
@@ -41,4 +40,5 @@
           flavor:
             name: "{{flavor_name}}"
           servers_per_tenant: 2
-
+        volume_types:
+          - "test"

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

@@ -26,6 +26,35 @@ CINDER_UTILS = "rally.plugins.openstack.scenarios.cinder.utils"
 CONF = cfg.CONF
 
 
+class CinderBasicTestCase(test.ScenarioTestCase):
+
+    def _get_context(self):
+        context = test.get_test_context()
+        context.update({
+            "admin": {
+                "id": "fake_user_id",
+                "credential": mock.MagicMock()
+            },
+            "user": {"id": "fake_user_id",
+                     "credential": mock.MagicMock()},
+            "tenant": {"id": "fake", "name": "fake",
+                       "volumes": [{"id": "uuid", "size": 1}],
+                       "servers": [1]}})
+        return context
+
+    def setUp(self):
+        super(CinderBasicTestCase, self).setUp()
+
+    @mock.patch("random.choice")
+    def test_get_random_server(self, mock_choice):
+        basic = utils.CinderBasic(self._get_context())
+        server_id = mock_choice(basic.context["tenant"]["servers"])
+        return_server = basic.get_random_server()
+        basic.clients("nova").servers.get.assert_called_once_with(server_id)
+        self.assertEqual(basic.clients("nova").servers.get.return_value,
+                         return_server)
+
+
 class CinderScenarioTestCase(test.ScenarioTestCase):
 
     def setUp(self):

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

@@ -20,14 +20,29 @@ from tests.unit import test
 
 class CinderBackupTestCase(test.ScenarioTestCase):
 
+    def setUp(self):
+        super(CinderBackupTestCase, self).setUp()
+        patch = mock.patch(
+            "rally.plugins.openstack.services.storage.block.BlockStorage")
+        self.addCleanup(patch.stop)
+        self.mock_cinder = patch.start()
+
+    def _get_context(self):
+        context = test.get_test_context()
+        context.update({
+            "admin": {
+                "id": "fake_user_id",
+                "credential": mock.MagicMock()
+            },
+            "user": {"id": "fake_user_id",
+                     "credential": mock.MagicMock()},
+            "tenant": {"id": "fake", "name": "fake"}})
+        return context
+
     def test_create_incremental_volume_backup(self):
-        fake_volume = mock.MagicMock()
+        mock_service = self.mock_cinder.return_value
-        fake_backup = mock.MagicMock()
+        scenario = volume_backups.CreateIncrementalVolumeBackup(
-        scenario = volume_backups.CreateIncrementalVolumeBackup(self.context)
+            self._get_context())
-        scenario._create_volume = mock.MagicMock(return_value=fake_volume)
-        scenario._create_backup = mock.MagicMock(return_value=fake_backup)
-        scenario._delete_volume = mock.MagicMock()
-        scenario._delete_backup = mock.MagicMock()
 
         volume_kwargs = {"some_var": "zaq"}
         backup_kwargs = {"incremental": True}
@@ -35,7 +50,9 @@ class CinderBackupTestCase(test.ScenarioTestCase):
         scenario.run(1, do_delete=True, create_volume_kwargs=volume_kwargs,
                      create_backup_kwargs=backup_kwargs)
 
-        self.assertEqual(2, scenario._create_backup.call_count)
+        self.assertEqual(2, mock_service.create_backup.call_count)
-        scenario._create_volume.assert_called_once_with(1, **volume_kwargs)
+        mock_service.create_volume.assert_called_once_with(1, **volume_kwargs)
-        scenario._delete_backup.assert_has_calls(fake_backup)
+        mock_service.delete_backup.assert_has_calls(
-        scenario._delete_volume.assert_called_once_with(fake_volume)
+            mock_service.create_backup.return_value)
+        mock_service.delete_volume.assert_called_once_with(
+            mock_service.create_volume.return_value)

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

@@ -18,85 +18,91 @@ from rally.plugins.openstack.scenarios.cinder import volume_types
 from tests.unit import test
 
 
-class fake_type(object):
-    name = "fake"
-
-
 class CinderVolumeTypesTestCase(test.ScenarioTestCase):
 
+    def setUp(self):
+        super(CinderVolumeTypesTestCase, self).setUp()
+        patch = mock.patch(
+            "rally.plugins.openstack.services.storage.block.BlockStorage")
+        self.addCleanup(patch.stop)
+        self.mock_cinder = patch.start()
+
     def _get_context(self):
         context = test.get_test_context()
         context.update({
-            "volume_types": [{"id": "fake_id",
+            "admin": {
-                              "name": "fake_name"}]})
+                "id": "fake_user_id",
+                "credential": mock.MagicMock()
+            },
+            "user": {"id": "fake_user_id",
+                     "credential": mock.MagicMock()},
+            "tenant": {"id": "fake", "name": "fake"}})
         return context
 
     def test_create_and_get_volume_type(self):
-        scenario = volume_types.CreateAndGetVolumeType(self.context)
+        mock_service = self.mock_cinder.return_value
-        scenario._create_volume_type = mock.Mock()
+        scenario = volume_types.CreateAndGetVolumeType(self._get_context())
-        scenario._get_volume_type = mock.Mock()
         scenario.run(fakeargs="f")
-        scenario._create_volume_type.assert_called_once_with(fakeargs="f")
+        mock_service.create_volume_type.assert_called_once_with(fakeargs="f")
-        scenario._get_volume_type.assert_called_once_with(
+        mock_service.get_volume_type.assert_called_once_with(
-            scenario._create_volume_type.return_value)
+            mock_service.create_volume_type.return_value)
 
     def test_create_and_delete_volume_type(self):
-        scenario = volume_types.CreateAndDeleteVolumeType(self.context)
+        mock_service = self.mock_cinder.return_value
-        scenario._create_volume_type = mock.Mock()
+        scenario = volume_types.CreateAndDeleteVolumeType(self._get_context())
-        scenario._delete_volume_type = mock.Mock()
         scenario.run(fakeargs="fakeargs")
-        scenario._create_volume_type.assert_called_once_with(
+        mock_service.create_volume_type.assert_called_once_with(
             fakeargs="fakeargs")
-        scenario._delete_volume_type.assert_called_once_with(
+        mock_service.delete_volume_type.assert_called_once_with(
-            scenario._create_volume_type.return_value)
+            mock_service.create_volume_type.return_value)
 
     def test_create_and_delete_encryption_type(self):
-        scenario = volume_types.CreateAndDeleteEncryptionType(
+        mock_service = self.mock_cinder.return_value
-            self._get_context())
+        context = self._get_context()
-        scenario._create_encryption_type = mock.Mock()
+        context.update({
-        scenario._delete_encryption_type = mock.Mock()
+            "volume_types": [{"id": "fake_id",
+                              "name": "fake_name"}]})
+        scenario = volume_types.CreateAndDeleteEncryptionType(context)
         scenario.run(create_specs="fakecreatespecs")
-        scenario._create_encryption_type.assert_called_once_with(
+        mock_service.create_encryption_type.assert_called_once_with(
-            "fake_id", "fakecreatespecs")
+            "fake_id", specs="fakecreatespecs")
-        scenario._delete_encryption_type.assert_called_once_with(
+        mock_service.delete_encryption_type.assert_called_once_with(
             "fake_id")
 
     def test_create_volume_type_and_encryption_type(self):
-        scenario = volume_types.CreateVolumeTypeAndEncryptionType(self.context)
+        mock_service = self.mock_cinder.return_value
-        scenario._create_volume_type = mock.Mock()
+        scenario = volume_types.CreateVolumeTypeAndEncryptionType(
-        scenario._create_encryption_type = mock.Mock()
+            self._get_context())
         scenario.run(specs="fakespecs", fakeargs="fakeargs")
-        scenario._create_volume_type.assert_called_once_with(
+        mock_service.create_volume_type.assert_called_once_with(
             fakeargs="fakeargs")
-        scenario._create_encryption_type.assert_called_once_with(
+        mock_service.create_encryption_type.assert_called_once_with(
-            scenario._create_volume_type.return_value, "fakespecs")
+            mock_service.create_volume_type.return_value,
+            specs="fakespecs")
 
     def test_create_and_list_encryption_type(self):
-        scenario = volume_types.CreateAndListEncryptionType(self.context)
+        mock_service = self.mock_cinder.return_value
-        scenario._create_volume_type = mock.Mock()
+        scenario = volume_types.CreateAndListEncryptionType(
-        scenario._create_encryption_type = mock.Mock()
+            self._get_context())
-        scenario._list_encryption_type = mock.Mock()
         scenario.run(specs="fakespecs", search_opts="fakeopts",
                      fakeargs="fakeargs")
-        scenario._create_volume_type.assert_called_once_with(
+        mock_service.create_volume_type.assert_called_once_with(
             fakeargs="fakeargs")
-        scenario._create_encryption_type.assert_called_once_with(
+        mock_service.create_encryption_type.assert_called_once_with(
-            scenario._create_volume_type.return_value, "fakespecs")
+            mock_service.create_volume_type.return_value,
-        scenario._list_encryption_type.assert_called_once_with(
+            specs="fakespecs")
+        mock_service.list_encryption_type.assert_called_once_with(
             "fakeopts")
 
     def test_create_and_set_volume_type_keys(self):
-        scenario = volume_types.CreateAndSetVolumeTypeKeys(self.context)
+        mock_service = self.mock_cinder.return_value
-
-        volume_type = mock.MagicMock()
         volume_type_key = {"volume_backend_name": "LVM_iSCSI"}
-        scenario._create_volume_type = mock.MagicMock()
+        scenario = volume_types.CreateAndSetVolumeTypeKeys(
-        scenario._set_volume_type_keys = mock.MagicMock()
+            self._get_context())
-
-        scenario._create_volume_type.return_value = volume_type
         scenario.run(volume_type_key, fakeargs="fakeargs")
 
-        scenario._create_volume_type.assert_called_once_with(
+        mock_service.create_volume_type.assert_called_once_with(
             fakeargs="fakeargs")
-        scenario._set_volume_type_keys.assert_called_once_with(volume_type,
+        mock_service.set_volume_type_keys.assert_called_once_with(
-                                                               volume_type_key)
+            mock_service.create_volume_type.return_value,
+            metadata=volume_type_key)

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

@@ -37,8 +37,8 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
         self.volume = mock.Mock()
         self.floating_ip = mock.Mock()
         self.image = mock.Mock()
-        self.context["iteration"] = 3
+        self.context.update(
-        self.context["config"] = {"users": {"tenants": 2}}
+            {"user": {"id": "fake_user_id", "credential": mock.MagicMock()}})
 
     def _context_with_networks(self, networks):
         retval = {"tenant": {"networks": networks}}
@@ -596,6 +596,15 @@ class NovaScenarioTestCase(test.ScenarioTestCase):
         self._test_atomic_action_timer(nova_scenario.atomic_actions(),
                                        "nova.resize_revert")
 
+    @mock.patch("rally.plugins.openstack.services.storage.block.BlockStorage")
+    def test__update_volume_resource(self, mock_block_storage):
+        volume = fakes.FakeVolume(id=1)
+        cinder = mock_block_storage.return_value
+        cinder.get_volume = mock.MagicMock()
+        nova_scenario = utils.NovaScenario(context=self.context)
+        self.assertEqual(cinder.get_volume.return_value,
+                         nova_scenario._update_volume_resource(volume))
+
     def test__attach_volume(self):
         expect_attach = mock.MagicMock()
         device = None

tests/unit/plugins/openstack/services/storage/test_block.py

@@ -167,6 +167,13 @@ class BlockTestCase(test.TestCase):
         self.service._impl.create_volume_type.assert_called_once_with(
             name="type", description=None, is_public=True)
 
+    def test_get_volume_type(self):
+        self.assertEqual(
+            self.service._impl.get_volume_type.return_value,
+            self.service.get_volume_type("volume_type"))
+        self.service._impl.get_volume_type.assert_called_once_with(
+            "volume_type")
+
     def test_delete_volume_type(self):
         self.service.delete_volume_type("volume_type")
         self.service._impl.delete_volume_type.assert_called_once_with(

tests/unit/plugins/openstack/services/storage/test_cinder_common.py

@@ -14,11 +14,13 @@
 
 import uuid
 
+import ddt
 import mock
 from oslo_config import cfg
 
 from rally import exceptions
 from rally.plugins.openstack import service
+from rally.plugins.openstack.services.storage import block
 from rally.plugins.openstack.services.storage import cinder_common
 from tests.unit import fakes
 from tests.unit import test
@@ -32,6 +34,7 @@ class FullCinder(service.Service, cinder_common.CinderMixin):
     pass
 
 
+@ddt.ddt
 class CinderMixinTestCase(test.ScenarioTestCase):
     def setUp(self):
         super(CinderMixinTestCase, self).setUp()
@@ -50,20 +53,63 @@ class CinderMixinTestCase(test.ScenarioTestCase):
         self.assertEqual(self.cinder,
                          self.service._get_client())
 
+    def test__update_resource_with_manage(self):
+        resource = mock.MagicMock(id=1, manager=mock.MagicMock())
+        self.assertEqual(resource.manager.get.return_value,
+                         self.service._update_resource(resource))
+        resource.manager.get.assert_called_once_with(
+            resource.id)
+
+    @ddt.data({"resource": block.Volume(id=1, name="vol",
+                                        size=1, status="st"),
+               "attr": "volumes"},
+              {"resource": block.VolumeSnapshot(id=2, name="snapshot",
+                                                volume_id=1, status="st"),
+               "attr": "volume_snapshots"},
+              {"resource": block.VolumeBackup(id=3, name="backup",
+                                              volume_id=1, status="st"),
+               "attr": "backups"})
+    @ddt.unpack
+    def test__update_resource_with_no_manage(self, resource, attr):
+        self.assertEqual(getattr(self.cinder, attr).get.return_value,
+                         self.service._update_resource(resource))
+        getattr(self.cinder, attr).get.assert_called_once_with(
+            resource.id)
+
+    def test__update_resource_with_not_found(self):
+        manager = mock.MagicMock()
+        resource = fakes.FakeResource(manager=manager, status="ERROR")
+
+        class NotFoundException(Exception):
+            http_status = 404
+
+        manager.get = mock.MagicMock(side_effect=NotFoundException)
+        self.assertRaises(exceptions.GetResourceNotFound,
+                          self.service._update_resource, resource)
+
+    def test__update_resource_with_http_exception(self):
+        manager = mock.MagicMock()
+        resource = fakes.FakeResource(manager=manager, status="ERROR")
+
+        class HTTPException(Exception):
+            pass
+
+        manager.get = mock.MagicMock(side_effect=HTTPException)
+        self.assertRaises(exceptions.GetResourceFailure,
+                          self.service._update_resource, resource)
+
     def test__wait_available_volume(self):
         volume = fakes.FakeVolume()
-        return_volume = self.service._wait_available_volume(volume)
+        self.assertEqual(self.mock_wait_for_status.mock.return_value,
+                         self.service._wait_available_volume(volume))
 
-        self.mock_get_from_manager.mock.assert_called_once_with()
         self.mock_wait_for_status.mock.assert_called_once_with(
             volume,
             ready_statuses=["available"],
-            update_resource=self.mock_get_from_manager.mock.return_value,
+            update_resource=self.service._update_resource,
             timeout=CONF.benchmark.cinder_volume_create_timeout,
             check_interval=CONF.benchmark.cinder_volume_create_poll_interval
         )
-        self.assertEqual(self.mock_wait_for_status.mock.return_value,
-                         return_volume)
 
     def test_list_volumes(self):
         self.assertEqual(self.cinder.volumes.list.return_value,
@@ -81,12 +127,11 @@ class CinderMixinTestCase(test.ScenarioTestCase):
         self.service.delete_volume(volume)
 
         self.cinder.volumes.delete.assert_called_once_with(volume)
-        self.mock_get_from_manager.mock.assert_called_once_with()
         self.mock_wait_for_status.mock.assert_called_once_with(
             volume,
             ready_statuses=["deleted"],
             check_deletion=True,
-            update_resource=self.mock_get_from_manager.mock.return_value,
+            update_resource=self.service._update_resource,
             timeout=CONF.benchmark.cinder_volume_delete_timeout,
             check_interval=CONF.benchmark.cinder_volume_delete_poll_interval
         )
@@ -97,7 +142,8 @@ class CinderMixinTestCase(test.ScenarioTestCase):
         self.service._wait_available_volume = mock.MagicMock()
         self.service._wait_available_volume.return_value = fakes.FakeVolume()
 
-        self.service.extend_volume(volume, 1)
+        self.assertEqual(self.service._wait_available_volume.return_value,
+                         self.service.extend_volume(volume, 1))
 
         self.cinder.volumes.extend.assert_called_once_with(volume, 1)
         self.service._wait_available_volume.assert_called_once_with(volume)
@@ -168,7 +214,7 @@ class CinderMixinTestCase(test.ScenarioTestCase):
             mock.call(
                 volume,
                 ready_statuses=["available"],
-                update_resource=self.mock_get_from_manager.mock.return_value,
+                update_resource=self.service._update_resource,
                 timeout=CONF.benchmark.cinder_volume_create_timeout,
                 check_interval=CONF.benchmark.
                 cinder_volume_create_poll_interval),
@@ -180,7 +226,6 @@ class CinderMixinTestCase(test.ScenarioTestCase):
                 check_interval=CONF.benchmark.
                 glance_image_create_poll_interval)
         ])
-        self.mock_get_from_manager.mock.assert_called_once_with()
         glance_client.images.get.assert_called_once_with(1)
 
     def test_delete_snapshot(self):
@@ -191,11 +236,10 @@ class CinderMixinTestCase(test.ScenarioTestCase):
             snapshot,
             ready_statuses=["deleted"],
             check_deletion=True,
-            update_resource=self.mock_get_from_manager.mock.return_value,
+            update_resource=self.service._update_resource,
             timeout=cfg.CONF.benchmark.cinder_volume_create_timeout,
             check_interval=cfg.CONF.benchmark
             .cinder_volume_create_poll_interval)
-        self.mock_get_from_manager.mock.assert_called_once_with()
 
     def test_delete_backup(self):
         backup = mock.Mock()
@@ -205,11 +249,10 @@ class CinderMixinTestCase(test.ScenarioTestCase):
             backup,
             ready_statuses=["deleted"],
             check_deletion=True,
-            update_resource=self.mock_get_from_manager.mock.return_value,
+            update_resource=self.service._update_resource,
             timeout=cfg.CONF.benchmark.cinder_volume_create_timeout,
             check_interval=cfg.CONF.benchmark
             .cinder_volume_create_poll_interval)
-        self.mock_get_from_manager.mock.assert_called_once_with()
 
     def test_restore_backup(self):
         backup = mock.Mock()
@@ -238,6 +281,12 @@ class CinderMixinTestCase(test.ScenarioTestCase):
             self.cinder.transfers.list.return_value,
             return_transfers_list)
 
+    def test_get_volume_type(self):
+        self.assertEqual(self.cinder.volume_types.get.return_value,
+                         self.service.get_volume_type("volume_type"))
+        self.cinder.volume_types.get.assert_called_once_with(
+            "volume_type")
+
     def test_delete_volume_type(self):
         volume_type = mock.Mock()
         self.service.delete_volume_type(volume_type)
@@ -341,20 +390,24 @@ class UnifiedCinderMixinTestCase(test.TestCase):
             id = 1
             name = "backup"
             volume_id = "volume"
+            status = "st"
         backup = self.service._unify_backup(SomeBackup())
         self.assertEqual(1, backup.id)
         self.assertEqual("backup", backup.name)
         self.assertEqual("volume", backup.volume_id)
+        self.assertEqual("st", backup.status)
 
     def test__unify_transfer(self):
         class SomeTransfer(object):
             id = 1
             name = "transfer"
             volume_id = "volume"
+            status = "st"
         transfer = self.service._unify_backup(SomeTransfer())
         self.assertEqual(1, transfer.id)
         self.assertEqual("transfer", transfer.name)
         self.assertEqual("volume", transfer.volume_id)
+        self.assertEqual("st", transfer.status)
 
     def test__unify_encryption_type(self):
         class SomeEncryptionType(object):
@@ -408,15 +461,6 @@ class UnifiedCinderMixinTestCase(test.TestCase):
         self.service.delete_backup("backup")
         self.service._impl.delete_backup.assert_called_once_with("backup")
 
-    def test_restore_backup(self):
-        self.service._unify_backup = mock.MagicMock()
-        self.assertEqual(self.service._unify_backup.return_value,
-                         self.service.restore_backup(1, volume_id=1))
-        self.service._impl.restore_backup.assert_called_once_with(1,
-                                                                  volume_id=1)
-        self.service._unify_backup.assert_called_once_with(
-            self.service._impl.restore_backup.return_value)
-
     def test_list_backups(self):
         self.service._unify_backup = mock.MagicMock()
         self.service._impl.list_backups.return_value = ["backup"]
@@ -437,6 +481,12 @@ class UnifiedCinderMixinTestCase(test.TestCase):
         self.service._unify_transfer.assert_called_once_with(
             "transfer")
 
+    def test_get_volume_type(self):
+        self.assertEqual(self.service._impl.get_volume_type.return_value,
+                         self.service.get_volume_type("volume_type"))
+        self.service._impl.get_volume_type.assert_called_once_with(
+            "volume_type")
+
     def test_delete_volume_type(self):
         self.assertEqual(self.service._impl.delete_volume_type.return_value,
                          self.service.delete_volume_type("volume_type"))

tests/unit/plugins/openstack/services/storage/test_cinder_v1.py

@@ -88,28 +88,25 @@ class CinderV1ServiceTestCase(test.ScenarioTestCase):
                          return_volume)
 
     def test_update_volume(self):
-        self.service.generate_random_name = mock.MagicMock(
+        return_value = {"volume": fakes.FakeVolume()}
-            return_value="volume")
+        self.cinder.volumes.update.return_value = return_value
 
-        return_volume = self.service.update_volume(
+        self.assertEqual(return_value["volume"],
-            1, display_description="fake")
+                         self.service.update_volume(1))
-
+        self.cinder.volumes.update.assert_called_once_with(1)
-        self.service.generate_random_name.assert_called_once_with()
-        self.cinder.volumes.update.assert_called_once_with(
-            1, display_name="volume", display_description="fake")
-        self.assertEqual(self.cinder.volumes.update.return_value,
-                         return_volume)
         self._test_atomic_action_timer(self.atomic_actions(),
                                        "cinder_v1.update_volume")
 
-    def test_update_volume_with_name(self):
+    def test_update_volume_with_name_description(self):
+        return_value = {"volume": fakes.FakeVolume()}
+        self.cinder.volumes.update.return_value = return_value
+
         return_volume = self.service.update_volume(
             1, display_name="volume", display_description="fake")
 
         self.cinder.volumes.update.assert_called_once_with(
             1, display_name="volume", display_description="fake")
-        self.assertEqual(self.cinder.volumes.update.return_value,
+        self.assertEqual(return_value["volume"], return_volume)
-                         return_volume)
         self._test_atomic_action_timer(self.atomic_actions(),
                                        "cinder_v1.update_volume")
 
@@ -224,20 +221,33 @@ class UnifiedCinderV1ServiceTestCase(test.TestCase):
             id = 1
             display_name = "volume"
             size = 1
+            status = "st"
         volume = self.service._unify_volume(SomeVolume())
         self.assertEqual(1, volume.id)
         self.assertEqual("volume", volume.name)
         self.assertEqual(1, volume.size)
+        self.assertEqual("st", volume.status)
+
+    def test__unify_volume_with_dict(self):
+        some_volume = {"display_name": "volume", "id": 1,
+                       "size": 1, "status": "st"}
+        volume = self.service._unify_volume(some_volume)
+        self.assertEqual(1, volume.id)
+        self.assertEqual("volume", volume.name)
+        self.assertEqual(1, volume.size)
+        self.assertEqual("st", volume.status)
 
     def test__unify_snapshot(self):
         class SomeSnapshot(object):
             id = 1
             display_name = "snapshot"
             volume_id = "volume"
+            status = "st"
         snapshot = self.service._unify_snapshot(SomeSnapshot())
         self.assertEqual(1, snapshot.id)
         self.assertEqual("snapshot", snapshot.name)
         self.assertEqual("volume", snapshot.volume_id)
+        self.assertEqual("st", snapshot.status)
 
     def test_create_volume(self):
         self.service._unify_volume = mock.MagicMock()
@@ -334,3 +344,12 @@ class UnifiedCinderV1ServiceTestCase(test.TestCase):
             self.service.create_volume_type(name="type"))
         self.service._impl.create_volume_type.assert_called_once_with(
             name="type")
+
+    def test_restore_backup(self):
+        self.service._unify_volume = mock.MagicMock()
+        self.assertEqual(self.service._unify_volume.return_value,
+                         self.service.restore_backup(1, volume_id=1))
+        self.service._impl.restore_backup.assert_called_once_with(1,
+                                                                  volume_id=1)
+        self.service._unify_volume.assert_called_once_with(
+            self.service._impl.restore_backup.return_value)

tests/unit/plugins/openstack/services/storage/test_cinder_v2.py

@@ -96,27 +96,25 @@ class CinderV2ServiceTestCase(test.ScenarioTestCase):
                          return_volume)
 
     def test_update_volume(self):
-        self.service.generate_random_name = mock.MagicMock(
+        return_value = {"volume": fakes.FakeVolume()}
-            return_value="volume")
+        self.cinder.volumes.update.return_value = return_value
 
-        return_volume = self.service.update_volume(1, description="fake")
+        self.assertEqual(return_value["volume"],
-
+                         self.service.update_volume(1))
-        self.service.generate_random_name.assert_called_once_with()
+        self.cinder.volumes.update.assert_called_once_with(1)
-        self.cinder.volumes.update.assert_called_once_with(1, name="volume",
-                                                           description="fake")
-        self.assertEqual(self.cinder.volumes.update.return_value,
-                         return_volume)
         self._test_atomic_action_timer(self.atomic_actions(),
                                        "cinder_v2.update_volume")
 
-    def test_update_volume_with_name(self):
+    def test_update_volume_with_name_description(self):
-        return_volume = self.service.update_volume(1, name="volume",
+        return_value = {"volume": fakes.FakeVolume()}
-                                                   description="fake")
+        self.cinder.volumes.update.return_value = return_value
 
-        self.cinder.volumes.update.assert_called_once_with(1, name="volume",
+        return_volume = self.service.update_volume(
-                                                           description="fake")
+            1, name="volume", description="fake")
-        self.assertEqual(self.cinder.volumes.update.return_value,
+
-                         return_volume)
+        self.cinder.volumes.update.assert_called_once_with(
+            1, name="volume", description="fake")
+        self.assertEqual(return_value["volume"], return_volume)
         self._test_atomic_action_timer(self.atomic_actions(),
                                        "cinder_v2.update_volume")
 
@@ -237,20 +235,32 @@ class UnifiedCinderV2ServiceTestCase(test.TestCase):
             id = 1
             name = "volume"
             size = 1
+            status = "st"
         volume = self.service._unify_volume(SomeVolume())
         self.assertEqual(1, volume.id)
         self.assertEqual("volume", volume.name)
         self.assertEqual(1, volume.size)
+        self.assertEqual("st", volume.status)
+
+    def test__unify_volume_with_dict(self):
+        some_volume = {"name": "volume", "id": 1, "size": 1, "status": "st"}
+        volume = self.service._unify_volume(some_volume)
+        self.assertEqual(1, volume.id)
+        self.assertEqual("volume", volume.name)
+        self.assertEqual(1, volume.size)
+        self.assertEqual("st", volume.status)
 
     def test__unify_snapshot(self):
         class SomeSnapshot(object):
             id = 1
             name = "snapshot"
             volume_id = "volume"
+            status = "st"
         snapshot = self.service._unify_snapshot(SomeSnapshot())
         self.assertEqual(1, snapshot.id)
         self.assertEqual("snapshot", snapshot.name)
         self.assertEqual("volume", snapshot.volume_id)
+        self.assertEqual("st", snapshot.status)
 
     def test_create_volume(self):
         self.service._unify_volume = mock.MagicMock()
@@ -355,3 +365,12 @@ class UnifiedCinderV2ServiceTestCase(test.TestCase):
                                             is_public=True))
         self.service._impl.create_volume_type.assert_called_once_with(
             name="type", description="desp", is_public=True)
+
+    def test_restore_backup(self):
+        self.service._unify_volume = mock.MagicMock()
+        self.assertEqual(self.service._unify_volume.return_value,
+                         self.service.restore_backup(1, volume_id=1))
+        self.service._impl.restore_backup.assert_called_once_with(1,
+                                                                  volume_id=1)
+        self.service._unify_volume.assert_called_once_with(
+            self.service._impl.restore_backup.return_value)