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

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

@@ -13,7 +13,9 @@
 
 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
@@ -23,6 +25,7 @@ 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
@@ -30,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
@@ -87,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)
+        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.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,
-            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 = [
@@ -176,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 = [
             ('properties', {'Alpha': 'a', 'Beta': 'b'}),
-            ('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={'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()
@@ -217,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()
@@ -258,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):
@@ -436,192 +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),
             ('read_only', 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, 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),
             ('read_only', 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, 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),
             ('read_only', 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.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),
             ('read_only', 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(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)
 
@@ -638,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(
@@ -665,7 +684,7 @@ class TestVolumeCreateLegacy(volume_fakes.TestVolume):
         """
         arglist = [
             '--size',
-            str(self.new_volume.size),
+            str(self.volume.size),
             '--hint',
             'k=v',
             '--hint',
@@ -680,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',
                 {
@@ -693,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'],
@@ -723,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)
 
@@ -837,7 +773,7 @@ class TestVolumeCreate(volume_fakes.TestVolume):
         )
 
         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')
@@ -846,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)
 
@@ -871,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)
 
@@ -892,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)
 
@@ -910,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)
 
@@ -934,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)
 
@@ -1239,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,
@@ -1282,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,
@@ -1328,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,
@@ -1371,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,
@@ -1416,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,
@@ -1459,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,
@@ -1502,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,
@@ -1544,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,
@@ -1587,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,
@@ -1660,6 +1605,7 @@ class TestVolumeList(volume_fakes.TestVolume):
                 'user_id': None,
                 'name': None,
                 'all_tenants': False,
+                'metadata': None,
             },
         )
         self.assertCountEqual(datalist, tuple(data))
@@ -1704,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,
@@ -1719,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(
@@ -1794,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()
@@ -2047,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
         )
 
 
@@ -2327,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())