python-openstackclient 8.0.0__py3-none-any.whl → 8.2.0__py3-none-any.whl

openstackclient/tests/unit/volume/v3/test_volume.py

@@ -13,15 +13,19 @@
 
 import copy
 from unittest import mock
+import uuid
 
+from openstack.block_storage.v3 import backup as _backup
 from openstack.block_storage.v3 import block_storage_summary as _summary
 from openstack.block_storage.v3 import snapshot as _snapshot
 from openstack.block_storage.v3 import volume as _volume
+from openstack import exceptions as sdk_exceptions
 from openstack.test import fakes as sdk_fakes
 from osc_lib.cli import format_columns
 from osc_lib import exceptions
 from osc_lib import utils
 
+from openstackclient.api import volume_v3
 from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes
 from openstackclient.tests.unit.image.v2 import fakes as image_fakes
 from openstackclient.tests.unit import utils as test_utils
@@ -29,55 +33,81 @@ from openstackclient.tests.unit.volume.v3 import fakes as volume_fakes
 from openstackclient.volume.v3 import volume
 
 
-# TODO(stephenfin): Combine these two test classes
-class TestVolumeCreateLegacy(volume_fakes.TestVolume):
-    project = identity_fakes.FakeProject.create_one_project()
-    user = identity_fakes.FakeUser.create_one_user()
-
+class TestVolumeCreate(volume_fakes.TestVolume):
     columns = (
         'attachments',
         'availability_zone',
         'bootable',
+        'cluster_name',
+        'consistencygroup_id',
+        'consumes_quota',
+        'created_at',
         'description',
+        'encrypted',
+        'encryption_key_id',
+        'group_id',
         'id',
+        'multiattach',
         'name',
+        'os-vol-host-attr:host',
+        'os-vol-mig-status-attr:migstat',
+        'os-vol-mig-status-attr:name_id',
+        'os-vol-tenant-attr:tenant_id',
         'properties',
+        'provider_id',
+        'replication_status',
+        'service_uuid',
+        'shared_targets',
         'size',
         'snapshot_id',
+        'source_volid',
         'status',
         'type',
+        'updated_at',
+        'user_id',
+        'volume_image_metadata',
+        'volume_type_id',
     )
 
     def setUp(self):
         super().setUp()
 
-        self.volumes_mock = self.volume_client.volumes
-        self.volumes_mock.reset_mock()
-
-        self.consistencygroups_mock = self.volume_client.consistencygroups
-        self.consistencygroups_mock.reset_mock()
-
-        self.snapshots_mock = self.volume_client.volume_snapshots
-        self.snapshots_mock.reset_mock()
-
-        self.backups_mock = self.volume_client.backups
-        self.backups_mock.reset_mock()
-
-        self.new_volume = volume_fakes.create_one_volume()
-        self.volumes_mock.create.return_value = self.new_volume
+        self.volume = sdk_fakes.generate_fake_resource(_volume.Volume)
+        self.volume_sdk_client.create_volume.return_value = self.volume
 
         self.datalist = (
-            self.new_volume.attachments,
-            self.new_volume.availability_zone,
-            self.new_volume.bootable,
-            self.new_volume.description,
-            self.new_volume.id,
-            self.new_volume.name,
-            format_columns.DictColumn(self.new_volume.metadata),
-            self.new_volume.size,
-            self.new_volume.snapshot_id,
-            self.new_volume.status,
-            self.new_volume.volume_type,
+            self.volume.attachments,
+            self.volume.availability_zone,
+            self.volume.is_bootable,
+            self.volume.cluster_name,
+            self.volume.consistency_group_id,
+            self.volume.consumes_quota,
+            self.volume.created_at,
+            self.volume.description,
+            self.volume.is_encrypted,
+            self.volume.encryption_key_id,
+            self.volume.group_id,
+            self.volume.id,
+            self.volume.is_multiattach,
+            self.volume.name,
+            self.volume.host,
+            self.volume.migration_status,
+            self.volume.migration_id,
+            self.volume.project_id,
+            format_columns.DictColumn(self.volume.metadata),
+            self.volume.provider_id,
+            self.volume.replication_status,
+            self.volume.service_uuid,
+            self.volume.shared_targets,
+            self.volume.size,
+            self.volume.snapshot_id,
+            self.volume.source_volume_id,
+            self.volume.status,
+            self.volume.volume_type,
+            self.volume.updated_at,
+            self.volume.user_id,
+            self.volume.volume_image_metadata,
+            self.volume.volume_type_id,
         )
 
         # Get the command object to test
@@ -86,87 +116,88 @@ class TestVolumeCreateLegacy(volume_fakes.TestVolume):
     def test_volume_create_min_options(self):
         arglist = [
             '--size',
-            str(self.new_volume.size),
+            str(self.volume.size),
         ]
         verifylist = [
-            ('size', self.new_volume.size),
+            ('size', self.volume.size),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.volumes_mock.create.assert_called_with(
-            size=self.new_volume.size,
+        self.volume_sdk_client.create_volume.assert_called_with(
+            size=self.volume.size,
             snapshot_id=None,
             name=None,
             description=None,
             volume_type=None,
             availability_zone=None,
             metadata=None,
-            imageRef=None,
-            source_volid=None,
-            consistencygroup_id=None,
+            image_id=None,
+            source_volume_id=None,
+            consistency_group_id=None,
             scheduler_hints=None,
             backup_id=None,
         )
 
         self.assertEqual(self.columns, columns)
-        self.assertCountEqual(self.datalist, data)
+        self.assertEqual(self.datalist, data)
 
     def test_volume_create_options(self):
-        consistency_group = volume_fakes.create_one_consistency_group()
-        self.consistencygroups_mock.get.return_value = consistency_group
+        consistency_group_id = 'cg123'
         arglist = [
             '--size',
-            str(self.new_volume.size),
+            str(self.volume.size),
             '--description',
-            self.new_volume.description,
+            self.volume.description,
             '--type',
-            self.new_volume.volume_type,
+            self.volume.volume_type,
             '--availability-zone',
-            self.new_volume.availability_zone,
+            self.volume.availability_zone,
             '--consistency-group',
-            consistency_group.id,
+            consistency_group_id,
             '--hint',
             'k=v',
-            self.new_volume.name,
+            self.volume.name,
         ]
         verifylist = [
-            ('size', self.new_volume.size),
-            ('description', self.new_volume.description),
-            ('type', self.new_volume.volume_type),
-            ('availability_zone', self.new_volume.availability_zone),
-            ('consistency_group', consistency_group.id),
+            ('size', self.volume.size),
+            ('description', self.volume.description),
+            ('type', self.volume.volume_type),
+            ('availability_zone', self.volume.availability_zone),
+            ('consistency_group', consistency_group_id),
             ('hint', {'k': 'v'}),
-            ('name', self.new_volume.name),
+            ('name', self.volume.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
-        columns, data = self.cmd.take_action(parsed_args)
-
-        self.volumes_mock.create.assert_called_with(
-            size=self.new_volume.size,
+        with mock.patch.object(
+            volume_v3,
+            'find_consistency_group',
+            return_value={'id': consistency_group_id},
+        ) as mock_find_cg:
+            columns, data = self.cmd.take_action(parsed_args)
+
+        self.volume_sdk_client.create_volume.assert_called_with(
+            size=self.volume.size,
             snapshot_id=None,
-            name=self.new_volume.name,
-            description=self.new_volume.description,
-            volume_type=self.new_volume.volume_type,
-            availability_zone=self.new_volume.availability_zone,
+            name=self.volume.name,
+            description=self.volume.description,
+            volume_type=self.volume.volume_type,
+            availability_zone=self.volume.availability_zone,
             metadata=None,
-            imageRef=None,
-            source_volid=None,
-            consistencygroup_id=consistency_group.id,
+            image_id=None,
+            source_volume_id=None,
+            consistency_group_id=consistency_group_id,
             scheduler_hints={'k': 'v'},
             backup_id=None,
         )
+        mock_find_cg.assert_called_once_with(
+            self.volume_sdk_client, consistency_group_id
+        )
 
         self.assertEqual(self.columns, columns)
-        self.assertCountEqual(self.datalist, data)
+        self.assertEqual(self.datalist, data)
 
     def test_volume_create_properties(self):
         arglist = [
@@ -175,38 +206,35 @@ class TestVolumeCreateLegacy(volume_fakes.TestVolume):
             '--property',
             'Beta=b',
             '--size',
-            str(self.new_volume.size),
-            self.new_volume.name,
+            str(self.volume.size),
+            self.volume.name,
         ]
         verifylist = [
-            ('property', {'Alpha': 'a', 'Beta': 'b'}),
-            ('size', self.new_volume.size),
-            ('name', self.new_volume.name),
+            ('properties', {'Alpha': 'a', 'Beta': 'b'}),
+            ('size', self.volume.size),
+            ('name', self.volume.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.volumes_mock.create.assert_called_with(
-            size=self.new_volume.size,
+        self.volume_sdk_client.create_volume.assert_called_with(
+            size=self.volume.size,
             snapshot_id=None,
-            name=self.new_volume.name,
+            name=self.volume.name,
             description=None,
             volume_type=None,
             availability_zone=None,
             metadata={'Alpha': 'a', 'Beta': 'b'},
-            imageRef=None,
-            source_volid=None,
-            consistencygroup_id=None,
+            image_id=None,
+            source_volume_id=None,
+            consistency_group_id=None,
             scheduler_hints=None,
             backup_id=None,
         )
 
         self.assertEqual(self.columns, columns)
-        self.assertCountEqual(self.datalist, data)
+        self.assertEqual(self.datalist, data)
 
     def test_volume_create_image_id(self):
         image = image_fakes.create_one_image()
@@ -216,38 +244,35 @@ class TestVolumeCreateLegacy(volume_fakes.TestVolume):
             '--image',
             image.id,
             '--size',
-            str(self.new_volume.size),
-            self.new_volume.name,
+            str(self.volume.size),
+            self.volume.name,
         ]
         verifylist = [
             ('image', image.id),
-            ('size', self.new_volume.size),
-            ('name', self.new_volume.name),
+            ('size', self.volume.size),
+            ('name', self.volume.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.volumes_mock.create.assert_called_with(
-            size=self.new_volume.size,
+        self.volume_sdk_client.create_volume.assert_called_with(
+            size=self.volume.size,
             snapshot_id=None,
-            name=self.new_volume.name,
+            name=self.volume.name,
             description=None,
             volume_type=None,
             availability_zone=None,
             metadata=None,
-            imageRef=image.id,
-            source_volid=None,
-            consistencygroup_id=None,
+            image_id=image.id,
+            source_volume_id=None,
+            consistency_group_id=None,
             scheduler_hints=None,
             backup_id=None,
         )
 
         self.assertEqual(self.columns, columns)
-        self.assertCountEqual(self.datalist, data)
+        self.assertEqual(self.datalist, data)
 
     def test_volume_create_image_name(self):
         image = image_fakes.create_one_image()
@@ -257,177 +282,173 @@ class TestVolumeCreateLegacy(volume_fakes.TestVolume):
             '--image',
             image.name,
             '--size',
-            str(self.new_volume.size),
-            self.new_volume.name,
+            str(self.volume.size),
+            self.volume.name,
         ]
         verifylist = [
             ('image', image.name),
-            ('size', self.new_volume.size),
-            ('name', self.new_volume.name),
+            ('size', self.volume.size),
+            ('name', self.volume.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.volumes_mock.create.assert_called_with(
-            size=self.new_volume.size,
+        self.volume_sdk_client.create_volume.assert_called_with(
+            size=self.volume.size,
             snapshot_id=None,
-            name=self.new_volume.name,
+            name=self.volume.name,
             description=None,
             volume_type=None,
             availability_zone=None,
             metadata=None,
-            imageRef=image.id,
-            source_volid=None,
-            consistencygroup_id=None,
+            image_id=image.id,
+            source_volume_id=None,
+            consistency_group_id=None,
             scheduler_hints=None,
             backup_id=None,
         )
 
         self.assertEqual(self.columns, columns)
-        self.assertCountEqual(self.datalist, data)
+        self.assertEqual(self.datalist, data)
 
     def test_volume_create_with_snapshot(self):
-        snapshot = volume_fakes.create_one_snapshot()
-        self.new_volume.snapshot_id = snapshot.id
+        snapshot = sdk_fakes.generate_fake_resource(_snapshot.Snapshot)
+        self.volume_sdk_client.find_snapshot.return_value = snapshot
+
         arglist = [
             '--snapshot',
-            self.new_volume.snapshot_id,
-            self.new_volume.name,
+            snapshot.id,
+            self.volume.name,
         ]
         verifylist = [
-            ('snapshot', self.new_volume.snapshot_id),
-            ('name', self.new_volume.name),
+            ('snapshot', snapshot.id),
+            ('name', self.volume.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
-        self.snapshots_mock.get.return_value = snapshot
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.volumes_mock.create.assert_called_once_with(
+        self.volume_sdk_client.create_volume.assert_called_with(
             size=snapshot.size,
             snapshot_id=snapshot.id,
-            name=self.new_volume.name,
+            name=self.volume.name,
             description=None,
             volume_type=None,
             availability_zone=None,
             metadata=None,
-            imageRef=None,
-            source_volid=None,
-            consistencygroup_id=None,
+            image_id=None,
+            source_volume_id=None,
+            consistency_group_id=None,
             scheduler_hints=None,
             backup_id=None,
         )
+        self.volume_sdk_client.find_snapshot.assert_called_once_with(
+            snapshot.id, ignore_missing=False
+        )
 
         self.assertEqual(self.columns, columns)
-        self.assertCountEqual(self.datalist, data)
+        self.assertEqual(self.datalist, data)
 
     def test_volume_create_with_backup(self):
         self.set_volume_api_version('3.47')
 
-        backup = volume_fakes.create_one_backup()
-        self.new_volume.backup_id = backup.id
+        backup = sdk_fakes.generate_fake_resource(_backup.Backup)
+        self.volume_sdk_client.find_backup.return_value = backup
+
         arglist = [
             '--backup',
-            self.new_volume.backup_id,
-            self.new_volume.name,
+            backup.id,
+            self.volume.name,
         ]
         verifylist = [
-            ('backup', self.new_volume.backup_id),
-            ('name', self.new_volume.name),
+            ('backup', backup.id),
+            ('name', self.volume.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
-        self.backups_mock.get.return_value = backup
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.volumes_mock.create.assert_called_once_with(
+        self.volume_sdk_client.create_volume.assert_called_with(
             size=backup.size,
             snapshot_id=None,
-            name=self.new_volume.name,
+            name=self.volume.name,
             description=None,
             volume_type=None,
             availability_zone=None,
             metadata=None,
-            imageRef=None,
-            source_volid=None,
-            consistencygroup_id=None,
+            image_id=None,
+            source_volume_id=None,
+            consistency_group_id=None,
             scheduler_hints=None,
             backup_id=backup.id,
         )
+        self.volume_sdk_client.find_backup.assert_called_once_with(
+            backup.id, ignore_missing=False
+        )
 
         self.assertEqual(self.columns, columns)
-        self.assertCountEqual(self.datalist, data)
+        self.assertEqual(self.datalist, data)
 
     def test_volume_create_with_backup_pre_v347(self):
-        backup = volume_fakes.create_one_backup()
-        self.new_volume.backup_id = backup.id
+        backup = sdk_fakes.generate_fake_resource(_backup.Backup)
+        self.volume_sdk_client.find_backup.return_value = backup
+
         arglist = [
             '--backup',
-            self.new_volume.backup_id,
-            self.new_volume.name,
+            backup.id,
+            self.volume.name,
         ]
         verifylist = [
-            ('backup', self.new_volume.backup_id),
-            ('name', self.new_volume.name),
+            ('backup', backup.id),
+            ('name', self.volume.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
-        self.backups_mock.get.return_value = backup
-
         exc = self.assertRaises(
             exceptions.CommandError, self.cmd.take_action, parsed_args
         )
         self.assertIn("--os-volume-api-version 3.47 or greater", str(exc))
 
+        self.volume_sdk_client.create_volume.assert_not_called()
+
     def test_volume_create_with_source_volume(self):
-        source_vol = "source_vol"
+        source_volume = sdk_fakes.generate_fake_resource(_volume.Volume)
+        self.volume_sdk_client.find_volume.return_value = source_volume
+
         arglist = [
             '--source',
-            self.new_volume.id,
-            source_vol,
+            source_volume.id,
+            self.volume.name,
         ]
         verifylist = [
-            ('source', self.new_volume.id),
-            ('name', source_vol),
+            ('source', source_volume.id),
+            ('name', self.volume.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
-        self.volumes_mock.get.return_value = self.new_volume
-
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.volumes_mock.create.assert_called_once_with(
-            size=self.new_volume.size,
+        self.volume_sdk_client.create_volume.assert_called_with(
+            size=source_volume.size,
             snapshot_id=None,
-            name=source_vol,
+            name=self.volume.name,
             description=None,
             volume_type=None,
             availability_zone=None,
             metadata=None,
-            imageRef=None,
-            source_volid=self.new_volume.id,
-            consistencygroup_id=None,
+            image_id=None,
+            source_volume_id=source_volume.id,
+            consistency_group_id=None,
             scheduler_hints=None,
             backup_id=None,
         )
+        self.volume_sdk_client.find_volume.assert_called_once_with(
+            source_volume.id, ignore_missing=False
+        )
 
         self.assertEqual(self.columns, columns)
-        self.assertCountEqual(self.datalist, data)
+        self.assertEqual(self.datalist, data)
 
     @mock.patch.object(utils, 'wait_for_status', return_value=True)
     def test_volume_create_with_bootable_and_readonly(self, mock_wait):
@@ -435,200 +456,191 @@ class TestVolumeCreateLegacy(volume_fakes.TestVolume):
             '--bootable',
             '--read-only',
             '--size',
-            str(self.new_volume.size),
-            self.new_volume.name,
+            str(self.volume.size),
+            self.volume.name,
         ]
         verifylist = [
             ('bootable', True),
-            ('non_bootable', False),
             ('read_only', True),
-            ('read_write', False),
-            ('size', self.new_volume.size),
-            ('name', self.new_volume.name),
+            ('size', self.volume.size),
+            ('name', self.volume.name),
         ]
 
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.volumes_mock.create.assert_called_with(
-            size=self.new_volume.size,
+        self.volume_sdk_client.create_volume.assert_called_with(
+            size=self.volume.size,
             snapshot_id=None,
-            name=self.new_volume.name,
+            name=self.volume.name,
             description=None,
             volume_type=None,
             availability_zone=None,
             metadata=None,
-            imageRef=None,
-            source_volid=None,
-            consistencygroup_id=None,
+            image_id=None,
+            source_volume_id=None,
+            consistency_group_id=None,
             scheduler_hints=None,
             backup_id=None,
         )
-
-        self.assertEqual(self.columns, columns)
-        self.assertCountEqual(self.datalist, data)
-        self.volumes_mock.set_bootable.assert_called_with(
-            self.new_volume.id, True
+        self.volume_sdk_client.set_volume_bootable_status.assert_called_once_with(
+            self.volume, True
         )
-        self.volumes_mock.update_readonly_flag.assert_called_with(
-            self.new_volume.id, True
+        self.volume_sdk_client.set_volume_readonly.assert_called_once_with(
+            self.volume, True
         )
 
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.datalist, data)
+
     @mock.patch.object(utils, 'wait_for_status', return_value=True)
     def test_volume_create_with_nonbootable_and_readwrite(self, mock_wait):
         arglist = [
             '--non-bootable',
             '--read-write',
             '--size',
-            str(self.new_volume.size),
-            self.new_volume.name,
+            str(self.volume.size),
+            self.volume.name,
         ]
         verifylist = [
             ('bootable', False),
-            ('non_bootable', True),
             ('read_only', False),
-            ('read_write', True),
-            ('size', self.new_volume.size),
-            ('name', self.new_volume.name),
+            ('size', self.volume.size),
+            ('name', self.volume.name),
         ]
 
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.volumes_mock.create.assert_called_with(
-            size=self.new_volume.size,
+        self.volume_sdk_client.create_volume.assert_called_with(
+            size=self.volume.size,
             snapshot_id=None,
-            name=self.new_volume.name,
+            name=self.volume.name,
             description=None,
             volume_type=None,
             availability_zone=None,
             metadata=None,
-            imageRef=None,
-            source_volid=None,
-            consistencygroup_id=None,
+            image_id=None,
+            source_volume_id=None,
+            consistency_group_id=None,
             scheduler_hints=None,
             backup_id=None,
         )
-
-        self.assertEqual(self.columns, columns)
-        self.assertCountEqual(self.datalist, data)
-        self.volumes_mock.set_bootable.assert_called_with(
-            self.new_volume.id, False
+        self.volume_sdk_client.set_volume_bootable_status.assert_called_once_with(
+            self.volume, False
         )
-        self.volumes_mock.update_readonly_flag.assert_called_with(
-            self.new_volume.id, False
+        self.volume_sdk_client.set_volume_readonly.assert_called_once_with(
+            self.volume, False
         )
 
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.datalist, data)
+
     @mock.patch.object(volume.LOG, 'error')
     @mock.patch.object(utils, 'wait_for_status', return_value=True)
     def test_volume_create_with_bootable_and_readonly_fail(
         self, mock_wait, mock_error
     ):
-        self.volumes_mock.set_bootable.side_effect = exceptions.CommandError()
-
-        self.volumes_mock.update_readonly_flag.side_effect = (
-            exceptions.CommandError()
+        self.volume_sdk_client.set_volume_bootable_status.side_effect = (
+            sdk_exceptions.NotFoundException('foo')
+        )
+        self.volume_sdk_client.set_volume_readonly.side_effect = (
+            sdk_exceptions.NotFoundException('foo')
         )
 
         arglist = [
             '--bootable',
             '--read-only',
             '--size',
-            str(self.new_volume.size),
-            self.new_volume.name,
+            str(self.volume.size),
+            self.volume.name,
         ]
         verifylist = [
             ('bootable', True),
-            ('non_bootable', False),
             ('read_only', True),
-            ('read_write', False),
-            ('size', self.new_volume.size),
-            ('name', self.new_volume.name),
+            ('size', self.volume.size),
+            ('name', self.volume.name),
         ]
 
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.volumes_mock.create.assert_called_with(
-            size=self.new_volume.size,
+        self.volume_sdk_client.create_volume.assert_called_with(
+            size=self.volume.size,
             snapshot_id=None,
-            name=self.new_volume.name,
+            name=self.volume.name,
             description=None,
             volume_type=None,
             availability_zone=None,
             metadata=None,
-            imageRef=None,
-            source_volid=None,
-            consistencygroup_id=None,
+            image_id=None,
+            source_volume_id=None,
+            consistency_group_id=None,
             scheduler_hints=None,
             backup_id=None,
         )
+        self.volume_sdk_client.set_volume_bootable_status.assert_called_once_with(
+            self.volume, True
+        )
+        self.volume_sdk_client.set_volume_readonly.assert_called_once_with(
+            self.volume, True
+        )
 
         self.assertEqual(2, mock_error.call_count)
         self.assertEqual(self.columns, columns)
-        self.assertCountEqual(self.datalist, data)
-        self.volumes_mock.set_bootable.assert_called_with(
-            self.new_volume.id, True
-        )
-        self.volumes_mock.update_readonly_flag.assert_called_with(
-            self.new_volume.id, True
-        )
+        self.assertEqual(self.datalist, data)
 
     @mock.patch.object(volume.LOG, 'error')
     @mock.patch.object(utils, 'wait_for_status', return_value=False)
     def test_volume_create_non_available_with_readonly(
-        self,
-        mock_wait,
-        mock_error,
+        self, mock_wait, mock_error
     ):
         arglist = [
             '--non-bootable',
             '--read-only',
             '--size',
-            str(self.new_volume.size),
-            self.new_volume.name,
+            str(self.volume.size),
+            self.volume.name,
         ]
         verifylist = [
             ('bootable', False),
-            ('non_bootable', True),
             ('read_only', True),
-            ('read_write', False),
-            ('size', self.new_volume.size),
-            ('name', self.new_volume.name),
+            ('size', self.volume.size),
+            ('name', self.volume.name),
         ]
 
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.volumes_mock.create.assert_called_with(
-            size=self.new_volume.size,
+        self.volume_sdk_client.create_volume.assert_called_with(
+            size=self.volume.size,
             snapshot_id=None,
-            name=self.new_volume.name,
+            name=self.volume.name,
             description=None,
             volume_type=None,
             availability_zone=None,
             metadata=None,
-            imageRef=None,
-            source_volid=None,
-            consistencygroup_id=None,
+            image_id=None,
+            source_volume_id=None,
+            consistency_group_id=None,
             scheduler_hints=None,
             backup_id=None,
         )
 
         self.assertEqual(2, mock_error.call_count)
         self.assertEqual(self.columns, columns)
-        self.assertCountEqual(self.datalist, data)
+        self.assertEqual(self.datalist, data)
 
     def test_volume_create_without_size(self):
         arglist = [
-            self.new_volume.name,
+            self.volume.name,
         ]
         verifylist = [
-            ('name', self.new_volume.name),
+            ('name', self.volume.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
@@ -645,15 +657,15 @@ class TestVolumeCreateLegacy(volume_fakes.TestVolume):
             '--snapshot',
             'source_snapshot',
             '--size',
-            str(self.new_volume.size),
-            self.new_volume.name,
+            str(self.volume.size),
+            self.volume.name,
         ]
         verifylist = [
             ('image', 'source_image'),
             ('source', 'source_volume'),
             ('snapshot', 'source_snapshot'),
-            ('size', self.new_volume.size),
-            ('name', self.new_volume.name),
+            ('size', self.volume.size),
+            ('name', self.volume.name),
         ]
 
         self.assertRaises(
@@ -672,7 +684,7 @@ class TestVolumeCreateLegacy(volume_fakes.TestVolume):
         """
         arglist = [
             '--size',
-            str(self.new_volume.size),
+            str(self.volume.size),
             '--hint',
             'k=v',
             '--hint',
@@ -687,10 +699,10 @@ class TestVolumeCreateLegacy(volume_fakes.TestVolume):
             'local_to_instance=v6',
             '--hint',
             'different_host=v7',
-            self.new_volume.name,
+            self.volume.name,
         ]
         verifylist = [
-            ('size', self.new_volume.size),
+            ('size', self.volume.size),
             (
                 'hint',
                 {
@@ -700,26 +712,23 @@ class TestVolumeCreateLegacy(volume_fakes.TestVolume):
                     'different_host': ['v5', 'v7'],
                 },
             ),
-            ('name', self.new_volume.name),
+            ('name', self.volume.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
-        # In base command class ShowOne in cliff, abstract method take_action()
-        # returns a two-part tuple with a tuple of column names and a tuple of
-        # data to be shown.
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.volumes_mock.create.assert_called_with(
-            size=self.new_volume.size,
+        self.volume_sdk_client.create_volume.assert_called_with(
+            size=self.volume.size,
             snapshot_id=None,
-            name=self.new_volume.name,
+            name=self.volume.name,
             description=None,
             volume_type=None,
             availability_zone=None,
             metadata=None,
-            imageRef=None,
-            source_volid=None,
-            consistencygroup_id=None,
+            image_id=None,
+            source_volume_id=None,
+            consistency_group_id=None,
             scheduler_hints={
                 'k': 'v2',
                 'same_host': ['v3', 'v4'],
@@ -730,102 +739,22 @@ class TestVolumeCreateLegacy(volume_fakes.TestVolume):
         )
 
         self.assertEqual(self.columns, columns)
-        self.assertCountEqual(self.datalist, data)
-
-
-class TestVolumeCreate(volume_fakes.TestVolume):
-    columns = (
-        'attachments',
-        'availability_zone',
-        'consistency_group_id',
-        'created_at',
-        'description',
-        'extended_replication_status',
-        'group_id',
-        'host',
-        'id',
-        'image_id',
-        'is_bootable',
-        'is_encrypted',
-        'is_multiattach',
-        'location',
-        'metadata',
-        'migration_id',
-        'migration_status',
-        'name',
-        'project_id',
-        'provider_id',
-        'replication_driver_data',
-        'replication_status',
-        'scheduler_hints',
-        'size',
-        'snapshot_id',
-        'source_volume_id',
-        'status',
-        'updated_at',
-        'user_id',
-        'volume_image_metadata',
-        'volume_type',
-    )
-
-    def setUp(self):
-        super().setUp()
-
-        self.new_volume = sdk_fakes.generate_fake_resource(
-            _volume.Volume, **{'size': 1}
-        )
-
-        self.datalist = (
-            self.new_volume.attachments,
-            self.new_volume.availability_zone,
-            self.new_volume.consistency_group_id,
-            self.new_volume.created_at,
-            self.new_volume.description,
-            self.new_volume.extended_replication_status,
-            self.new_volume.group_id,
-            self.new_volume.host,
-            self.new_volume.id,
-            self.new_volume.image_id,
-            self.new_volume.is_bootable,
-            self.new_volume.is_encrypted,
-            self.new_volume.is_multiattach,
-            self.new_volume.location,
-            self.new_volume.metadata,
-            self.new_volume.migration_id,
-            self.new_volume.migration_status,
-            self.new_volume.name,
-            self.new_volume.project_id,
-            self.new_volume.provider_id,
-            self.new_volume.replication_driver_data,
-            self.new_volume.replication_status,
-            self.new_volume.scheduler_hints,
-            self.new_volume.size,
-            self.new_volume.snapshot_id,
-            self.new_volume.source_volume_id,
-            self.new_volume.status,
-            self.new_volume.updated_at,
-            self.new_volume.user_id,
-            self.new_volume.volume_image_metadata,
-            self.new_volume.volume_type,
-        )
-
-        # Get the command object to test
-        self.cmd = volume.CreateVolume(self.app, None)
+        self.assertEqual(self.datalist, data)
 
     def test_volume_create_remote_source(self):
-        self.volume_sdk_client.manage_volume.return_value = self.new_volume
+        self.volume_sdk_client.manage_volume.return_value = self.volume
 
         arglist = [
             '--remote-source',
             'key=val',
             '--host',
             'fake_host',
-            self.new_volume.name,
+            self.volume.name,
         ]
         verifylist = [
             ('remote_source', {'key': 'val'}),
             ('host', 'fake_host'),
-            ('name', self.new_volume.name),
+            ('name', self.volume.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
@@ -838,13 +767,13 @@ class TestVolumeCreate(volume_fakes.TestVolume):
             description=parsed_args.description,
             volume_type=parsed_args.type,
             availability_zone=parsed_args.availability_zone,
-            metadata=parsed_args.property,
+            metadata=parsed_args.properties,
             bootable=parsed_args.bootable,
             cluster=getattr(parsed_args, 'cluster', None),
         )
 
         self.assertEqual(self.columns, columns)
-        self.assertCountEqual(self.datalist, data)
+        self.assertEqual(self.datalist, data)
 
     def test_volume_create_remote_source_pre_v316(self):
         self.set_volume_api_version('3.15')
@@ -853,12 +782,12 @@ class TestVolumeCreate(volume_fakes.TestVolume):
             'key=val',
             '--cluster',
             'fake_cluster',
-            self.new_volume.name,
+            self.volume.name,
         ]
         verifylist = [
             ('remote_source', {'key': 'val'}),
             ('cluster', 'fake_cluster'),
-            ('name', self.new_volume.name),
+            ('name', self.volume.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
@@ -878,13 +807,13 @@ class TestVolumeCreate(volume_fakes.TestVolume):
             'fake_host',
             '--cluster',
             'fake_cluster',
-            self.new_volume.name,
+            self.volume.name,
         ]
         verifylist = [
             ('remote_source', {'key': 'val'}),
             ('host', 'fake_host'),
             ('cluster', 'fake_cluster'),
-            ('name', self.new_volume.name),
+            ('name', self.volume.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
@@ -899,11 +828,11 @@ class TestVolumeCreate(volume_fakes.TestVolume):
         arglist = [
             '--remote-source',
             'key=val',
-            self.new_volume.name,
+            self.volume.name,
         ]
         verifylist = [
             ('remote_source', {'key': 'val'}),
-            ('name', self.new_volume.name),
+            ('name', self.volume.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
@@ -917,15 +846,15 @@ class TestVolumeCreate(volume_fakes.TestVolume):
     def test_volume_create_remote_source_size(self):
         arglist = [
             '--size',
-            str(self.new_volume.size),
+            str(self.volume.size),
             '--remote-source',
             'key=val',
-            self.new_volume.name,
+            self.volume.name,
         ]
         verifylist = [
-            ('size', self.new_volume.size),
+            ('size', self.volume.size),
             ('remote_source', {'key': 'val'}),
-            ('name', self.new_volume.name),
+            ('name', self.volume.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
@@ -941,15 +870,15 @@ class TestVolumeCreate(volume_fakes.TestVolume):
     def test_volume_create_host_no_remote_source(self):
         arglist = [
             '--size',
-            str(self.new_volume.size),
+            str(self.volume.size),
             '--host',
             'fake_host',
-            self.new_volume.name,
+            self.volume.name,
         ]
         verifylist = [
-            ('size', self.new_volume.size),
+            ('size', self.volume.size),
             ('host', 'fake_host'),
-            ('name', self.new_volume.name),
+            ('name', self.volume.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
@@ -962,16 +891,17 @@ class TestVolumeCreate(volume_fakes.TestVolume):
         )
 
 
-class TestVolumeDeleteLegacy(volume_fakes.TestVolume):
+class TestVolumeDelete(volume_fakes.TestVolume):
     def setUp(self):
         super().setUp()
 
         self.volumes_mock = self.volume_client.volumes
         self.volumes_mock.reset_mock()
 
-        self.volumes_mock.delete.return_value = None
-        self.volumes = volume_fakes.create_volumes(count=1)
-        self.volumes_mock.get = volume_fakes.get_volumes(self.volumes, 0)
+        self.volumes = list(sdk_fakes.generate_fake_resources(_volume.Volume))
+        self.volume_sdk_client.find_volume.side_effect = self.volumes
+        self.volume_sdk_client.delete_volume.return_value = None
+        self.volume_sdk_client.unmanage_volume.return_value = None
 
         # Get the command object to mock
         self.cmd = volume.DeleteVolume(self.app, None)
@@ -986,11 +916,14 @@ class TestVolumeDeleteLegacy(volume_fakes.TestVolume):
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
+        self.assertIsNone(result)
 
-        self.volumes_mock.delete.assert_called_once_with(
-            self.volumes[0].id, cascade=False
+        self.volume_sdk_client.find_volume.assert_called_once_with(
+            self.volumes[0].id, ignore_missing=False
+        )
+        self.volume_sdk_client.delete_volume.assert_called_once_with(
+            self.volumes[0].id, cascade=False, force=False
         )
-        self.assertIsNone(result)
 
     def test_volume_delete_multi_volumes(self):
         arglist = [v.id for v in self.volumes]
@@ -1002,12 +935,21 @@ class TestVolumeDeleteLegacy(volume_fakes.TestVolume):
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
-
-        calls = [mock.call(v.id, cascade=False) for v in self.volumes]
-        self.volumes_mock.delete.assert_has_calls(calls)
         self.assertIsNone(result)
 
+        self.volume_sdk_client.find_volume.assert_has_calls(
+            [mock.call(v.id, ignore_missing=False) for v in self.volumes]
+        )
+        self.volume_sdk_client.delete_volume.assert_has_calls(
+            [mock.call(v.id, cascade=False, force=False) for v in self.volumes]
+        )
+
     def test_volume_delete_multi_volumes_with_exception(self):
+        self.volume_sdk_client.find_volume.side_effect = [
+            self.volumes[0],
+            sdk_exceptions.NotFoundException(),
+        ]
+
         arglist = [
             self.volumes[0].id,
             'unexist_volume',
@@ -1015,27 +957,28 @@ class TestVolumeDeleteLegacy(volume_fakes.TestVolume):
         verifylist = [
             ('force', False),
             ('purge', False),
-            ('volumes', arglist),
+            ('volumes', [self.volumes[0].id, 'unexist_volume']),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
-        find_mock_result = [self.volumes[0], exceptions.CommandError]
-        with mock.patch.object(
-            utils, 'find_resource', side_effect=find_mock_result
-        ) as find_mock:
-            try:
-                self.cmd.take_action(parsed_args)
-                self.fail('CommandError should be raised.')
-            except exceptions.CommandError as e:
-                self.assertEqual('1 of 2 volumes failed to delete.', str(e))
-
-            find_mock.assert_any_call(self.volumes_mock, self.volumes[0].id)
-            find_mock.assert_any_call(self.volumes_mock, 'unexist_volume')
-
-            self.assertEqual(2, find_mock.call_count)
-            self.volumes_mock.delete.assert_called_once_with(
-                self.volumes[0].id, cascade=False
-            )
+        exc = self.assertRaises(
+            exceptions.CommandError,
+            self.cmd.take_action,
+            parsed_args,
+        )
+        self.assertEqual('1 of 2 volumes failed to delete.', str(exc))
+
+        self.volume_sdk_client.find_volume.assert_has_calls(
+            [
+                mock.call(self.volumes[0].id, ignore_missing=False),
+                mock.call('unexist_volume', ignore_missing=False),
+            ]
+        )
+        self.volume_sdk_client.delete_volume.assert_has_calls(
+            [
+                mock.call(self.volumes[0].id, cascade=False, force=False),
+            ]
+        )
 
     def test_volume_delete_with_purge(self):
         arglist = [
@@ -1050,11 +993,14 @@ class TestVolumeDeleteLegacy(volume_fakes.TestVolume):
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
+        self.assertIsNone(result)
 
-        self.volumes_mock.delete.assert_called_once_with(
-            self.volumes[0].id, cascade=True
+        self.volume_sdk_client.find_volume.assert_called_once_with(
+            self.volumes[0].id, ignore_missing=False
+        )
+        self.volume_sdk_client.delete_volume.assert_called_once_with(
+            self.volumes[0].id, cascade=True, force=False
         )
-        self.assertIsNone(result)
 
     def test_volume_delete_with_force(self):
         arglist = [
@@ -1069,49 +1015,38 @@ class TestVolumeDeleteLegacy(volume_fakes.TestVolume):
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
-
-        self.volumes_mock.force_delete.assert_called_once_with(
-            self.volumes[0].id
-        )
         self.assertIsNone(result)
 
-
-class TestVolumeDelete(volume_fakes.TestVolume):
-    def setUp(self):
-        super().setUp()
-
-        self.volumes_mock = self.volume_client.volumes
-        self.volumes_mock.reset_mock()
-        self.volume_sdk_client.unmanage_volume.return_value = None
-
-        # Get the command object to mock
-        self.cmd = volume.DeleteVolume(self.app, None)
+        self.volume_sdk_client.find_volume.assert_called_once_with(
+            self.volumes[0].id, ignore_missing=False
+        )
+        self.volume_sdk_client.delete_volume.assert_called_once_with(
+            self.volumes[0].id, cascade=False, force=True
+        )
 
     def test_volume_delete_remote(self):
-        vol = sdk_fakes.generate_fake_resource(_volume.Volume, **{'size': 1})
-        self.volumes_mock.get.return_value = vol
-
-        arglist = ['--remote', vol.id]
+        arglist = ['--remote', self.volumes[0].id]
         verifylist = [
             ("remote", True),
             ("force", False),
             ("purge", False),
-            ("volumes", [vol.id]),
+            ("volumes", [self.volumes[0].id]),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
-
-        self.volume_sdk_client.unmanage_volume.assert_called_once_with(vol.id)
         self.assertIsNone(result)
 
-    def test_volume_delete_multi_volumes_remote(self):
-        volumes = sdk_fakes.generate_fake_resources(
-            _volume.Volume, count=3, attrs={'size': 1}
+        self.volume_sdk_client.find_volume.assert_called_once_with(
+            self.volumes[0].id, ignore_missing=False
+        )
+        self.volume_sdk_client.delete_volume.assert_not_called()
+        self.volume_sdk_client.unmanage_volume.assert_called_once_with(
+            self.volumes[0].id
         )
 
-        arglist = ['--remote']
-        arglist += [v.id for v in volumes]
+    def test_volume_delete_multi_volumes_remote(self):
+        arglist = ['--remote'] + [v.id for v in self.volumes]
         verifylist = [
             ('remote', True),
             ('force', False),
@@ -1121,24 +1056,27 @@ class TestVolumeDelete(volume_fakes.TestVolume):
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
-
-        calls = [mock.call(v.id) for v in volumes]
-        self.volume_sdk_client.unmanage_volume.assert_has_calls(calls)
         self.assertIsNone(result)
 
-    def test_volume_delete_remote_with_purge(self):
-        vol = sdk_fakes.generate_fake_resource(_volume.Volume, **{'size': 1})
+        self.volume_sdk_client.find_volume.assert_has_calls(
+            [mock.call(v.id, ignore_missing=False) for v in self.volumes]
+        )
+        self.volume_sdk_client.delete_volume.assert_not_called()
+        self.volume_sdk_client.unmanage_volume.assert_has_calls(
+            [mock.call(v.id) for v in self.volumes]
+        )
 
+    def test_volume_delete_remote_with_purge(self):
         arglist = [
             '--remote',
             '--purge',
-            vol.id,
+            self.volumes[0].id,
         ]
         verifylist = [
             ('remote', True),
             ('force', False),
             ('purge', True),
-            ('volumes', [vol.id]),
+            ('volumes', [self.volumes[0].id]),
         ]
 
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
@@ -1151,19 +1089,21 @@ class TestVolumeDelete(volume_fakes.TestVolume):
             str(exc),
         )
 
-    def test_volume_delete_remote_with_force(self):
-        vol = sdk_fakes.generate_fake_resource(_volume.Volume, **{'size': 1})
+        self.volume_sdk_client.find_volume.assert_not_called()
+        self.volume_sdk_client.delete_volume.assert_not_called()
+        self.volume_sdk_client.unmanage_volume.assert_not_called()
 
+    def test_volume_delete_remote_with_force(self):
         arglist = [
             '--remote',
             '--force',
-            vol.id,
+            self.volumes[0].id,
         ]
         verifylist = [
             ('remote', True),
             ('force', True),
             ('purge', False),
-            ('volumes', [vol.id]),
+            ('volumes', [self.volumes[0].id]),
         ]
 
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
@@ -1176,6 +1116,10 @@ class TestVolumeDelete(volume_fakes.TestVolume):
             str(exc),
         )
 
+        self.volume_sdk_client.find_volume.assert_not_called()
+        self.volume_sdk_client.delete_volume.assert_not_called()
+        self.volume_sdk_client.unmanage_volume.assert_not_called()
+
 
 class TestVolumeList(volume_fakes.TestVolume):
     project = identity_fakes.FakeProject.create_one_project()
@@ -1231,6 +1175,7 @@ class TestVolumeList(volume_fakes.TestVolume):
             'user_id': None,
             'name': None,
             'status': None,
+            'metadata': None,
         }
         self.volumes_mock.list.assert_called_once_with(
             search_opts=search_opts,
@@ -1274,6 +1219,7 @@ class TestVolumeList(volume_fakes.TestVolume):
             'user_id': None,
             'name': None,
             'status': None,
+            'metadata': None,
         }
         self.volumes_mock.list.assert_called_once_with(
             search_opts=search_opts,
@@ -1320,6 +1266,7 @@ class TestVolumeList(volume_fakes.TestVolume):
             'user_id': None,
             'name': None,
             'status': None,
+            'metadata': None,
         }
         self.volumes_mock.list.assert_called_once_with(
             search_opts=search_opts,
@@ -1363,6 +1310,7 @@ class TestVolumeList(volume_fakes.TestVolume):
             'user_id': self.user.id,
             'name': None,
             'status': None,
+            'metadata': None,
         }
         self.volumes_mock.list.assert_called_once_with(
             search_opts=search_opts,
@@ -1408,6 +1356,7 @@ class TestVolumeList(volume_fakes.TestVolume):
             'user_id': self.user.id,
             'name': None,
             'status': None,
+            'metadata': None,
         }
         self.volumes_mock.list.assert_called_once_with(
             search_opts=search_opts,
@@ -1451,6 +1400,7 @@ class TestVolumeList(volume_fakes.TestVolume):
             'user_id': None,
             'name': self.mock_volume.name,
             'status': None,
+            'metadata': None,
         }
         self.volumes_mock.list.assert_called_once_with(
             search_opts=search_opts,
@@ -1494,6 +1444,7 @@ class TestVolumeList(volume_fakes.TestVolume):
             'user_id': None,
             'name': None,
             'status': self.mock_volume.status,
+            'metadata': None,
         }
         self.volumes_mock.list.assert_called_once_with(
             search_opts=search_opts,
@@ -1536,6 +1487,7 @@ class TestVolumeList(volume_fakes.TestVolume):
             'user_id': None,
             'name': None,
             'status': None,
+            'metadata': None,
         }
         self.volumes_mock.list.assert_called_once_with(
             search_opts=search_opts,
@@ -1579,6 +1531,7 @@ class TestVolumeList(volume_fakes.TestVolume):
             'user_id': None,
             'name': None,
             'status': None,
+            'metadata': None,
         }
         self.volumes_mock.list.assert_called_once_with(
             search_opts=search_opts,
@@ -1652,6 +1605,7 @@ class TestVolumeList(volume_fakes.TestVolume):
                 'user_id': None,
                 'name': None,
                 'all_tenants': False,
+                'metadata': None,
             },
         )
         self.assertCountEqual(datalist, tuple(data))
@@ -1696,6 +1650,7 @@ class TestVolumeList(volume_fakes.TestVolume):
             'user_id': None,
             'name': None,
             'status': None,
+            'metadata': None,
         }
         self.volumes_mock.list.assert_called_once_with(
             search_opts=search_opts,
@@ -1711,71 +1666,79 @@ class TestVolumeList(volume_fakes.TestVolume):
 
 
 class TestVolumeMigrate(volume_fakes.TestVolume):
-    _volume = volume_fakes.create_one_volume()
-
     def setUp(self):
         super().setUp()
 
-        self.volumes_mock = self.volume_client.volumes
-        self.volumes_mock.reset_mock()
+        self.volume = sdk_fakes.generate_fake_resource(_volume.Volume)
+        self.volume_sdk_client.find_volume.return_value = self.volume
+        self.volume_sdk_client.migrate_volume.return_value = None
 
-        self.volumes_mock.get.return_value = self._volume
-        self.volumes_mock.migrate_volume.return_value = None
-        # Get the command object to test
         self.cmd = volume.MigrateVolume(self.app, None)
 
     def test_volume_migrate(self):
         arglist = [
             "--host",
             "host@backend-name#pool",
-            self._volume.id,
+            self.volume.id,
         ]
         verifylist = [
             ("force_host_copy", False),
             ("lock_volume", False),
             ("host", "host@backend-name#pool"),
-            ("volume", self._volume.id),
+            ("volume", self.volume.id),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
-        self.volumes_mock.get.assert_called_once_with(self._volume.id)
-        self.volumes_mock.migrate_volume.assert_called_once_with(
-            self._volume.id, "host@backend-name#pool", False, False
-        )
         self.assertIsNone(result)
 
+        self.volume_sdk_client.find_volume.assert_called_with(
+            self.volume.id, ignore_missing=False
+        )
+        self.volume_sdk_client.migrate_volume.assert_called_once_with(
+            self.volume.id,
+            host="host@backend-name#pool",
+            force_host_copy=False,
+            lock_volume=False,
+        )
+
     def test_volume_migrate_with_option(self):
         arglist = [
             "--force-host-copy",
             "--lock-volume",
             "--host",
             "host@backend-name#pool",
-            self._volume.id,
+            self.volume.id,
         ]
         verifylist = [
             ("force_host_copy", True),
             ("lock_volume", True),
             ("host", "host@backend-name#pool"),
-            ("volume", self._volume.id),
+            ("volume", self.volume.id),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
-        self.volumes_mock.get.assert_called_once_with(self._volume.id)
-        self.volumes_mock.migrate_volume.assert_called_once_with(
-            self._volume.id, "host@backend-name#pool", True, True
-        )
         self.assertIsNone(result)
 
+        self.volume_sdk_client.find_volume.assert_called_with(
+            self.volume.id, ignore_missing=False
+        )
+        self.volume_sdk_client.migrate_volume.assert_called_once_with(
+            self.volume.id,
+            host="host@backend-name#pool",
+            force_host_copy=True,
+            lock_volume=True,
+        )
+
     def test_volume_migrate_without_host(self):
         arglist = [
-            self._volume.id,
+            self.volume.id,
         ]
         verifylist = [
             ("force_host_copy", False),
             ("lock_volume", False),
-            ("volume", self._volume.id),
+            ("volume", self.volume.id),
         ]
 
         self.assertRaises(
@@ -1786,6 +1749,9 @@ class TestVolumeMigrate(volume_fakes.TestVolume):
             verifylist,
         )
 
+        self.volume_sdk_client.find_volume.assert_not_called()
+        self.volume_sdk_client.migrate_volume.assert_not_called()
+
 
 class TestVolumeSet(volume_fakes.TestVolume):
     volume_type = volume_fakes.create_one_volume_type()
@@ -1815,16 +1781,16 @@ class TestVolumeSet(volume_fakes.TestVolume):
             self.new_volume.id,
         ]
         verifylist = [
-            ('property', {'a': 'b', 'c': 'd'}),
+            ('properties', {'a': 'b', 'c': 'd'}),
+            ('read_only', None),
+            ('bootable', None),
             ('volume', self.new_volume.id),
-            ('bootable', False),
-            ('non_bootable', False),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         self.cmd.take_action(parsed_args)
         self.volumes_mock.set_metadata.assert_called_with(
-            self.new_volume.id, parsed_args.property
+            self.new_volume.id, parsed_args.properties
         )
 
     def test_volume_set_image_property(self):
@@ -1836,10 +1802,10 @@ class TestVolumeSet(volume_fakes.TestVolume):
             self.new_volume.id,
         ]
         verifylist = [
-            ('image_property', {'Alpha': 'a', 'Beta': 'b'}),
+            ('image_properties', {'Alpha': 'a', 'Beta': 'b'}),
+            ('read_only', None),
+            ('bootable', None),
             ('volume', self.new_volume.id),
-            ('bootable', False),
-            ('non_bootable', False),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
@@ -1847,15 +1813,15 @@ class TestVolumeSet(volume_fakes.TestVolume):
         # returns nothing
         self.cmd.take_action(parsed_args)
         self.volumes_mock.set_image_metadata.assert_called_with(
-            self.new_volume.id, parsed_args.image_property
+            self.new_volume.id, parsed_args.image_properties
         )
 
     def test_volume_set_state(self):
         arglist = ['--state', 'error', self.new_volume.id]
         verifylist = [
-            ('read_only', False),
-            ('read_write', False),
             ('state', 'error'),
+            ('read_only', None),
+            ('bootable', None),
             ('volume', self.new_volume.id),
         ]
 
@@ -1919,36 +1885,40 @@ class TestVolumeSet(volume_fakes.TestVolume):
 
     def test_volume_set_bootable(self):
         arglist = [
-            ['--bootable', self.new_volume.id],
-            ['--non-bootable', self.new_volume.id],
+            '--bootable',
+            self.new_volume.id,
         ]
         verifylist = [
-            [
-                ('bootable', True),
-                ('non_bootable', False),
-                ('volume', self.new_volume.id),
-            ],
-            [
-                ('bootable', False),
-                ('non_bootable', True),
-                ('volume', self.new_volume.id),
-            ],
+            ('bootable', True),
+            ('volume', self.new_volume.id),
         ]
-        for index in range(len(arglist)):
-            parsed_args = self.check_parser(
-                self.cmd, arglist[index], verifylist[index]
-            )
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
-            self.cmd.take_action(parsed_args)
-            self.volumes_mock.set_bootable.assert_called_with(
-                self.new_volume.id, verifylist[index][0][1]
-            )
+        self.cmd.take_action(parsed_args)
+        self.volumes_mock.set_bootable.assert_called_with(
+            self.new_volume.id, verifylist[0][1]
+        )
+
+    def test_volume_set_non_bootable(self):
+        arglist = [
+            '--non-bootable',
+            self.new_volume.id,
+        ]
+        verifylist = [
+            ('bootable', False),
+            ('volume', self.new_volume.id),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        self.cmd.take_action(parsed_args)
+        self.volumes_mock.set_bootable.assert_called_with(
+            self.new_volume.id, verifylist[0][1]
+        )
 
     def test_volume_set_readonly(self):
         arglist = ['--read-only', self.new_volume.id]
         verifylist = [
             ('read_only', True),
-            ('read_write', False),
             ('volume', self.new_volume.id),
         ]
 
@@ -1964,7 +1934,6 @@ class TestVolumeSet(volume_fakes.TestVolume):
         arglist = ['--read-write', self.new_volume.id]
         verifylist = [
             ('read_only', False),
-            ('read_write', True),
             ('volume', self.new_volume.id),
         ]
 
@@ -2036,41 +2005,91 @@ class TestVolumeShow(volume_fakes.TestVolume):
     def setUp(self):
         super().setUp()
 
-        self.volumes_mock = self.volume_client.volumes
-        self.volumes_mock.reset_mock()
+        self.volume = sdk_fakes.generate_fake_resource(_volume.Volume)
+        self.volume_sdk_client.find_volume.return_value = self.volume
+
+        self.columns = (
+            'attachments',
+            'availability_zone',
+            'bootable',
+            'cluster_name',
+            'consistencygroup_id',
+            'consumes_quota',
+            'created_at',
+            'description',
+            'encrypted',
+            'encryption_key_id',
+            'group_id',
+            'id',
+            'multiattach',
+            'name',
+            'os-vol-host-attr:host',
+            'os-vol-mig-status-attr:migstat',
+            'os-vol-mig-status-attr:name_id',
+            'os-vol-tenant-attr:tenant_id',
+            'properties',
+            'provider_id',
+            'replication_status',
+            'service_uuid',
+            'shared_targets',
+            'size',
+            'snapshot_id',
+            'source_volid',
+            'status',
+            'type',
+            'updated_at',
+            'user_id',
+            'volume_image_metadata',
+            'volume_type_id',
+        )
+        self.data = (
+            self.volume.attachments,
+            self.volume.availability_zone,
+            self.volume.is_bootable,
+            self.volume.cluster_name,
+            self.volume.consistency_group_id,
+            self.volume.consumes_quota,
+            self.volume.created_at,
+            self.volume.description,
+            self.volume.is_encrypted,
+            self.volume.encryption_key_id,
+            self.volume.group_id,
+            self.volume.id,
+            self.volume.is_multiattach,
+            self.volume.name,
+            self.volume.host,
+            self.volume.migration_status,
+            self.volume.migration_id,
+            self.volume.project_id,
+            format_columns.DictColumn(self.volume.metadata),
+            self.volume.provider_id,
+            self.volume.replication_status,
+            self.volume.service_uuid,
+            self.volume.shared_targets,
+            self.volume.size,
+            self.volume.snapshot_id,
+            self.volume.source_volume_id,
+            self.volume.status,
+            self.volume.volume_type,
+            self.volume.updated_at,
+            self.volume.user_id,
+            self.volume.volume_image_metadata,
+            self.volume.volume_type_id,
+        )
 
-        self._volume = volume_fakes.create_one_volume()
-        self.volumes_mock.get.return_value = self._volume
-        # Get the command object to test
         self.cmd = volume.ShowVolume(self.app, None)
 
     def test_volume_show(self):
-        arglist = [self._volume.id]
-        verifylist = [("volume", self._volume.id)]
+        arglist = [self.volume.id]
+        verifylist = [("volume", self.volume.id)]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         columns, data = self.cmd.take_action(parsed_args)
-        self.volumes_mock.get.assert_called_with(self._volume.id)
 
-        self.assertEqual(
-            tuple(sorted(self._volume.keys())),
-            columns,
-        )
-        self.assertTupleEqual(
-            (
-                self._volume.attachments,
-                self._volume.availability_zone,
-                self._volume.bootable,
-                self._volume.description,
-                self._volume.id,
-                self._volume.name,
-                format_columns.DictColumn(self._volume.metadata),
-                self._volume.size,
-                self._volume.snapshot_id,
-                self._volume.status,
-                self._volume.volume_type,
-            ),
-            data,
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
+        self.volume_sdk_client.find_volume.assert_called_with(
+            self.volume.id, ignore_missing=False
         )
 
 
@@ -2100,7 +2119,7 @@ class TestVolumeUnset(volume_fakes.TestVolume):
             self.new_volume.id,
         ]
         verifylist = [
-            ('image_property', {'Alpha': 'a', 'Beta': 'b'}),
+            ('image_properties', {'Alpha': 'a', 'Beta': 'b'}),
             ('volume', self.new_volume.id),
         ]
         parsed_args = self.check_parser(self.cmd_set, arglist, verifylist)
@@ -2116,7 +2135,7 @@ class TestVolumeUnset(volume_fakes.TestVolume):
             self.new_volume.id,
         ]
         verifylist_unset = [
-            ('image_property', ['Alpha']),
+            ('image_properties', ['Alpha']),
             ('volume', self.new_volume.id),
         ]
         parsed_args_unset = self.check_parser(
@@ -2128,7 +2147,7 @@ class TestVolumeUnset(volume_fakes.TestVolume):
         self.cmd_unset.take_action(parsed_args_unset)
 
         self.volumes_mock.delete_image_metadata.assert_called_with(
-            self.new_volume.id, parsed_args_unset.image_property
+            self.new_volume.id, parsed_args_unset.image_properties
         )
 
     def test_volume_unset_image_property_fail(self):
@@ -2143,8 +2162,8 @@ class TestVolumeUnset(volume_fakes.TestVolume):
             self.new_volume.id,
         ]
         verifylist = [
-            ('image_property', ['Alpha']),
-            ('property', ['Beta']),
+            ('image_properties', ['Alpha']),
+            ('properties', ['Beta']),
             ('volume', self.new_volume.id),
         ]
         parsed_args = self.check_parser(self.cmd_unset, arglist, verifylist)
@@ -2157,10 +2176,10 @@ class TestVolumeUnset(volume_fakes.TestVolume):
                 'One or more of the unset operations failed', str(e)
             )
         self.volumes_mock.delete_image_metadata.assert_called_with(
-            self.new_volume.id, parsed_args.image_property
+            self.new_volume.id, parsed_args.image_properties
         )
         self.volumes_mock.delete_metadata.assert_called_with(
-            self.new_volume.id, parsed_args.property
+            self.new_volume.id, parsed_args.properties
         )
 
 
@@ -2316,29 +2335,45 @@ class TestVolumeRevertToSnapshot(volume_fakes.TestVolume):
 
 class TestColumns(volume_fakes.TestVolume):
     def test_attachments_column_without_server_cache(self):
-        _volume = volume_fakes.create_one_volume()
-        server_id = _volume.attachments[0]['server_id']
-        device = _volume.attachments[0]['device']
+        vol = sdk_fakes.generate_fake_resource(
+            _volume.Volume,
+            attachments=[
+                {
+                    'device': '/dev/' + uuid.uuid4().hex,
+                    'server_id': uuid.uuid4().hex,
+                },
+            ],
+        )
+        server_id = vol.attachments[0]['server_id']
+        device = vol.attachments[0]['device']
 
-        col = volume.AttachmentsColumn(_volume.attachments, {})
+        col = volume.AttachmentsColumn(vol.attachments, {})
         self.assertEqual(
             f'Attached to {server_id} on {device} ',
             col.human_readable(),
         )
-        self.assertEqual(_volume.attachments, col.machine_readable())
+        self.assertEqual(vol.attachments, col.machine_readable())
 
     def test_attachments_column_with_server_cache(self):
-        _volume = volume_fakes.create_one_volume()
+        vol = sdk_fakes.generate_fake_resource(
+            _volume.Volume,
+            attachments=[
+                {
+                    'device': '/dev/' + uuid.uuid4().hex,
+                    'server_id': uuid.uuid4().hex,
+                },
+            ],
+        )
 
-        server_id = _volume.attachments[0]['server_id']
-        device = _volume.attachments[0]['device']
+        server_id = vol.attachments[0]['server_id']
+        device = vol.attachments[0]['device']
         fake_server = mock.Mock()
         fake_server.name = 'fake-server-name'
         server_cache = {server_id: fake_server}
 
-        col = volume.AttachmentsColumn(_volume.attachments, server_cache)
+        col = volume.AttachmentsColumn(vol.attachments, server_cache)
         self.assertEqual(
             'Attached to {} on {} '.format('fake-server-name', device),
             col.human_readable(),
         )
-        self.assertEqual(_volume.attachments, col.machine_readable())
+        self.assertEqual(vol.attachments, col.machine_readable())