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

openstackclient/tests/unit/volume/v2/test_volume_snapshot.py

@@ -13,9 +13,12 @@
 
 from unittest import mock
 
+from openstack.block_storage.v2 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.tests.unit.identity.v3 import fakes as project_fakes
 from openstackclient.tests.unit import utils as test_utils
@@ -23,19 +26,7 @@ from openstackclient.tests.unit.volume.v2 import fakes as volume_fakes
 from openstackclient.volume.v2 import volume_snapshot
 
 
-class TestVolumeSnapshot(volume_fakes.TestVolume):
-    def setUp(self):
-        super().setUp()
-
-        self.snapshots_mock = self.volume_client.volume_snapshots
-        self.snapshots_mock.reset_mock()
-        self.volumes_mock = self.volume_client.volumes
-        self.volumes_mock.reset_mock()
-        self.project_mock = self.identity_client.projects
-        self.project_mock.reset_mock()
-
-
-class TestVolumeSnapshotCreate(TestVolumeSnapshot):
+class TestVolumeSnapshotCreate(volume_fakes.TestVolume):
     columns = (
         'created_at',
         'description',
@@ -50,69 +41,71 @@ class TestVolumeSnapshotCreate(TestVolumeSnapshot):
     def setUp(self):
         super().setUp()
 
-        self.volume = volume_fakes.create_one_volume()
-        self.new_snapshot = volume_fakes.create_one_snapshot(
-            attrs={'volume_id': self.volume.id}
+        self.volume = sdk_fakes.generate_fake_resource(_volume.Volume)
+        self.volume_sdk_client.find_volume.return_value = self.volume
+        self.snapshot = sdk_fakes.generate_fake_resource(
+            _snapshot.Snapshot, volume_id=self.volume.id
         )
+        self.volume_sdk_client.create_snapshot.return_value = self.snapshot
+        self.volume_sdk_client.manage_snapshot.return_value = self.snapshot
 
         self.data = (
-            self.new_snapshot.created_at,
-            self.new_snapshot.description,
-            self.new_snapshot.id,
-            self.new_snapshot.name,
-            format_columns.DictColumn(self.new_snapshot.metadata),
-            self.new_snapshot.size,
-            self.new_snapshot.status,
-            self.new_snapshot.volume_id,
-        )
-
-        self.volumes_mock.get.return_value = self.volume
-        self.snapshots_mock.create.return_value = self.new_snapshot
-        self.snapshots_mock.manage.return_value = self.new_snapshot
-        # Get the command object to test
+            self.snapshot.created_at,
+            self.snapshot.description,
+            self.snapshot.id,
+            self.snapshot.name,
+            format_columns.DictColumn(self.snapshot.metadata),
+            self.snapshot.size,
+            self.snapshot.status,
+            self.snapshot.volume_id,
+        )
+
         self.cmd = volume_snapshot.CreateVolumeSnapshot(self.app, None)
 
     def test_snapshot_create(self):
         arglist = [
             "--volume",
-            self.new_snapshot.volume_id,
+            self.snapshot.volume_id,
             "--description",
-            self.new_snapshot.description,
+            self.snapshot.description,
             "--force",
             '--property',
             'Alpha=a',
             '--property',
             'Beta=b',
-            self.new_snapshot.name,
+            self.snapshot.name,
         ]
         verifylist = [
-            ("volume", self.new_snapshot.volume_id),
-            ("description", self.new_snapshot.description),
+            ("volume", self.snapshot.volume_id),
+            ("description", self.snapshot.description),
             ("force", True),
-            ('property', {'Alpha': 'a', 'Beta': 'b'}),
-            ("snapshot_name", self.new_snapshot.name),
+            ('properties', {'Alpha': 'a', 'Beta': 'b'}),
+            ("snapshot_name", self.snapshot.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.snapshots_mock.create.assert_called_with(
-            self.new_snapshot.volume_id,
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
+        self.volume_sdk_client.find_volume.assert_called_once_with(
+            self.snapshot.volume_id, ignore_missing=False
+        )
+        self.volume_sdk_client.create_snapshot.assert_called_with(
+            volume_id=self.snapshot.volume_id,
             force=True,
-            name=self.new_snapshot.name,
-            description=self.new_snapshot.description,
+            name=self.snapshot.name,
+            description=self.snapshot.description,
             metadata={'Alpha': 'a', 'Beta': 'b'},
         )
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.data, data)
 
     def test_snapshot_create_without_name(self):
         arglist = [
             "--volume",
-            self.new_snapshot.volume_id,
+            self.snapshot.volume_id,
         ]
         verifylist = [
-            ("volume", self.new_snapshot.volume_id),
+            ("volume", self.snapshot.volume_id),
         ]
         self.assertRaises(
             test_utils.ParserException,
@@ -125,29 +118,31 @@ class TestVolumeSnapshotCreate(TestVolumeSnapshot):
     def test_snapshot_create_without_volume(self):
         arglist = [
             "--description",
-            self.new_snapshot.description,
+            self.snapshot.description,
             "--force",
-            self.new_snapshot.name,
+            self.snapshot.name,
         ]
         verifylist = [
-            ("description", self.new_snapshot.description),
+            ("description", self.snapshot.description),
             ("force", True),
-            ("snapshot_name", self.new_snapshot.name),
+            ("snapshot_name", self.snapshot.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.volumes_mock.get.assert_called_once_with(self.new_snapshot.name)
-        self.snapshots_mock.create.assert_called_once_with(
-            self.new_snapshot.volume_id,
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
+        self.volume_sdk_client.find_volume.assert_called_once_with(
+            self.snapshot.name, ignore_missing=False
+        )
+        self.volume_sdk_client.create_snapshot.assert_called_once_with(
+            volume_id=self.snapshot.volume_id,
             force=True,
-            name=self.new_snapshot.name,
-            description=self.new_snapshot.description,
+            name=self.snapshot.name,
+            description=self.snapshot.description,
             metadata=None,
         )
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.data, data)
 
     def test_snapshot_create_with_remote_source(self):
         arglist = [
@@ -156,8 +151,8 @@ class TestVolumeSnapshotCreate(TestVolumeSnapshot):
             '--remote-source',
             'source-id=test_source_id',
             '--volume',
-            self.new_snapshot.volume_id,
-            self.new_snapshot.name,
+            self.snapshot.volume_id,
+            self.snapshot.name,
         ]
         ref_dict = {
             'source-name': 'test_source_name',
@@ -165,35 +160,38 @@ class TestVolumeSnapshotCreate(TestVolumeSnapshot):
         }
         verifylist = [
             ('remote_source', ref_dict),
-            ('volume', self.new_snapshot.volume_id),
-            ("snapshot_name", self.new_snapshot.name),
+            ('volume', self.snapshot.volume_id),
+            ("snapshot_name", self.snapshot.name),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.snapshots_mock.manage.assert_called_with(
-            volume_id=self.new_snapshot.volume_id,
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
+        self.volume_sdk_client.find_volume.assert_called_once_with(
+            self.snapshot.volume_id, ignore_missing=False
+        )
+        self.volume_sdk_client.manage_snapshot.assert_called_with(
+            volume_id=self.snapshot.volume_id,
             ref=ref_dict,
-            name=self.new_snapshot.name,
+            name=self.snapshot.name,
             description=None,
             metadata=None,
         )
-        self.snapshots_mock.create.assert_not_called()
-        self.assertEqual(self.columns, columns)
-        self.assertEqual(self.data, data)
+        self.volume_sdk_client.create_snapshot.assert_not_called()
 
 
-class TestVolumeSnapshotDelete(TestVolumeSnapshot):
-    snapshots = volume_fakes.create_snapshots(count=2)
-
+class TestVolumeSnapshotDelete(volume_fakes.TestVolume):
     def setUp(self):
         super().setUp()
 
-        self.snapshots_mock.get = volume_fakes.get_snapshots(self.snapshots)
-        self.snapshots_mock.delete.return_value = None
+        self.snapshots = list(
+            sdk_fakes.generate_fake_resources(_snapshot.Snapshot)
+        )
+        self.volume_sdk_client.find_snapshot.side_effect = self.snapshots
+        self.volume_sdk_client.delete_snapshot.return_value = None
 
-        # Get the command object to mock
         self.cmd = volume_snapshot.DeleteVolumeSnapshot(self.app, None)
 
     def test_snapshot_delete(self):
@@ -202,11 +200,14 @@ class TestVolumeSnapshotDelete(TestVolumeSnapshot):
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
+        self.assertIsNone(result)
 
-        self.snapshots_mock.delete.assert_called_with(
-            self.snapshots[0].id, False
+        self.volume_sdk_client.find_snapshot.assert_called_once_with(
+            self.snapshots[0].id, ignore_missing=False
+        )
+        self.volume_sdk_client.delete_snapshot.assert_called_once_with(
+            self.snapshots[0].id, force=False
         )
-        self.assertIsNone(result)
 
     def test_snapshot_delete_with_force(self):
         arglist = ['--force', self.snapshots[0].id]
@@ -214,11 +215,14 @@ class TestVolumeSnapshotDelete(TestVolumeSnapshot):
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
+        self.assertIsNone(result)
 
-        self.snapshots_mock.delete.assert_called_with(
-            self.snapshots[0].id, True
+        self.volume_sdk_client.find_snapshot.assert_called_once_with(
+            self.snapshots[0].id, ignore_missing=False
+        )
+        self.volume_sdk_client.delete_snapshot.assert_called_once_with(
+            self.snapshots[0].id, force=True
         )
-        self.assertIsNone(result)
 
     def test_delete_multiple_snapshots(self):
         arglist = []
@@ -227,17 +231,24 @@ class TestVolumeSnapshotDelete(TestVolumeSnapshot):
         verifylist = [
             ('snapshots', arglist),
         ]
-
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        result = self.cmd.take_action(parsed_args)
 
-        calls = []
-        for s in self.snapshots:
-            calls.append(mock.call(s.id, False))
-        self.snapshots_mock.delete.assert_has_calls(calls)
+        result = self.cmd.take_action(parsed_args)
         self.assertIsNone(result)
 
+        self.volume_sdk_client.find_snapshot.assert_has_calls(
+            [mock.call(x.id, ignore_missing=False) for x in self.snapshots]
+        )
+        self.volume_sdk_client.delete_snapshot.assert_has_calls(
+            [mock.call(x.id, force=False) for x in self.snapshots]
+        )
+
     def test_delete_multiple_snapshots_with_exception(self):
+        self.volume_sdk_client.find_snapshot.side_effect = [
+            self.snapshots[0],
+            sdk_exceptions.NotFoundException(),
+        ]
+
         arglist = [
             self.snapshots[0].id,
             'unexist_snapshot',
@@ -248,73 +259,77 @@ class TestVolumeSnapshotDelete(TestVolumeSnapshot):
 
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
-        find_mock_result = [self.snapshots[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 snapshots failed to delete.', str(e))
-
-            find_mock.assert_any_call(
-                self.snapshots_mock, self.snapshots[0].id
-            )
-            find_mock.assert_any_call(self.snapshots_mock, 'unexist_snapshot')
+        exc = self.assertRaises(
+            exceptions.CommandError,
+            self.cmd.take_action,
+            parsed_args,
+        )
+        self.assertEqual('1 of 2 snapshots failed to delete.', str(exc))
 
-            self.assertEqual(2, find_mock.call_count)
-            self.snapshots_mock.delete.assert_called_once_with(
-                self.snapshots[0].id, False
-            )
+        self.volume_sdk_client.find_snapshot.assert_has_calls(
+            [
+                mock.call(self.snapshots[0].id, ignore_missing=False),
+                mock.call('unexist_snapshot', ignore_missing=False),
+            ]
+        )
+        self.volume_sdk_client.delete_snapshot.assert_has_calls(
+            [
+                mock.call(self.snapshots[0].id, force=False),
+            ]
+        )
 
 
-class TestVolumeSnapshotList(TestVolumeSnapshot):
-    volume = volume_fakes.create_one_volume()
-    project = project_fakes.FakeProject.create_one_project()
-    snapshots = volume_fakes.create_snapshots(
-        attrs={'volume_id': volume.name}, count=3
-    )
+class TestVolumeSnapshotList(volume_fakes.TestVolume):
+    def setUp(self):
+        super().setUp()
 
-    columns = ["ID", "Name", "Description", "Status", "Size"]
-    columns_long = columns + ["Created At", "Volume", "Properties"]
-
-    data = []
-    for s in snapshots:
-        data.append(
-            (
-                s.id,
-                s.name,
-                s.description,
-                s.status,
-                s.size,
+        self.volume = sdk_fakes.generate_fake_resource(_volume.Volume)
+        self.snapshots = list(
+            sdk_fakes.generate_fake_resources(
+                _snapshot.Snapshot, attrs={'volume_id': self.volume.name}
             )
         )
-    data_long = []
-    for s in snapshots:
-        data_long.append(
-            (
-                s.id,
-                s.name,
-                s.description,
-                s.status,
-                s.size,
-                s.created_at,
-                volume_snapshot.VolumeIdColumn(
-                    s.volume_id, volume_cache={volume.id: volume}
-                ),
-                format_columns.DictColumn(s.metadata),
-            )
+        self.project = project_fakes.FakeProject.create_one_project()
+        self.volume_sdk_client.volumes.return_value = [self.volume]
+        self.volume_sdk_client.find_volume.return_value = self.volume
+        self.volume_sdk_client.snapshots.return_value = self.snapshots
+        self.project_mock = self.identity_client.projects
+        self.project_mock.get.return_value = self.project
+
+        self.columns = ("ID", "Name", "Description", "Status", "Size")
+        self.columns_long = self.columns + (
+            "Created At",
+            "Volume",
+            "Properties",
         )
 
-    def setUp(self):
-        super().setUp()
+        self.data = []
+        self.data_long = []
+        for s in self.snapshots:
+            self.data.append(
+                (
+                    s.id,
+                    s.name,
+                    s.description,
+                    s.status,
+                    s.size,
+                )
+            )
+            self.data_long.append(
+                (
+                    s.id,
+                    s.name,
+                    s.description,
+                    s.status,
+                    s.size,
+                    s.created_at,
+                    volume_snapshot.VolumeIdColumn(
+                        s.volume_id, volume_cache={self.volume.id: self.volume}
+                    ),
+                    format_columns.DictColumn(s.metadata),
+                )
+            )
 
-        self.volumes_mock.list.return_value = [self.volume]
-        self.volumes_mock.get.return_value = self.volume
-        self.project_mock.get.return_value = self.project
-        self.snapshots_mock.list.return_value = self.snapshots
-        # Get the command to test
         self.cmd = volume_snapshot.ListVolumeSnapshot(self.app, None)
 
     def test_snapshot_list_without_options(self):
@@ -324,16 +339,14 @@ class TestVolumeSnapshotList(TestVolumeSnapshot):
 
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.snapshots_mock.list.assert_called_once_with(
+        self.volume_sdk_client.snapshots.assert_called_once_with(
             limit=None,
             marker=None,
-            search_opts={
-                'all_tenants': False,
-                'name': None,
-                'status': None,
-                'project_id': None,
-                'volume_id': None,
-            },
+            all_projects=False,
+            name=None,
+            status=None,
+            project_id=None,
+            volume_id=None,
         )
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, list(data))
@@ -359,16 +372,14 @@ class TestVolumeSnapshotList(TestVolumeSnapshot):
 
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.snapshots_mock.list.assert_called_once_with(
+        self.volume_sdk_client.snapshots.assert_called_once_with(
             limit=2,
             marker=self.snapshots[0].id,
-            search_opts={
-                'all_tenants': True,
-                'project_id': self.project.id,
-                'name': None,
-                'status': None,
-                'volume_id': None,
-            },
+            all_projects=True,
+            project_id=self.project.id,
+            name=None,
+            status=None,
+            volume_id=None,
         )
         self.assertEqual(self.columns_long, columns)
         self.assertEqual(self.data_long, list(data))
@@ -382,16 +393,14 @@ class TestVolumeSnapshotList(TestVolumeSnapshot):
 
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.snapshots_mock.list.assert_called_once_with(
+        self.volume_sdk_client.snapshots.assert_called_once_with(
             limit=None,
             marker=None,
-            search_opts={
-                'all_tenants': True,
-                'name': None,
-                'status': None,
-                'project_id': None,
-                'volume_id': None,
-            },
+            all_projects=True,
+            name=None,
+            status=None,
+            project_id=None,
+            volume_id=None,
         )
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, list(data))
@@ -410,16 +419,14 @@ class TestVolumeSnapshotList(TestVolumeSnapshot):
 
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.snapshots_mock.list.assert_called_once_with(
+        self.volume_sdk_client.snapshots.assert_called_once_with(
             limit=None,
             marker=None,
-            search_opts={
-                'all_tenants': False,
-                'name': self.snapshots[0].name,
-                'status': None,
-                'project_id': None,
-                'volume_id': None,
-            },
+            all_projects=False,
+            name=self.snapshots[0].name,
+            status=None,
+            project_id=None,
+            volume_id=None,
         )
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, list(data))
@@ -427,27 +434,25 @@ class TestVolumeSnapshotList(TestVolumeSnapshot):
     def test_snapshot_list_status_option(self):
         arglist = [
             '--status',
-            self.snapshots[0].status,
+            'available',
         ]
         verifylist = [
             ('all_projects', False),
             ('long', False),
-            ('status', self.snapshots[0].status),
+            ('status', 'available'),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.snapshots_mock.list.assert_called_once_with(
+        self.volume_sdk_client.snapshots.assert_called_once_with(
             limit=None,
             marker=None,
-            search_opts={
-                'all_tenants': False,
-                'name': None,
-                'status': self.snapshots[0].status,
-                'project_id': None,
-                'volume_id': None,
-            },
+            all_projects=False,
+            name=None,
+            status='available',
+            project_id=None,
+            volume_id=None,
         )
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, list(data))
@@ -466,16 +471,14 @@ class TestVolumeSnapshotList(TestVolumeSnapshot):
 
         columns, data = self.cmd.take_action(parsed_args)
 
-        self.snapshots_mock.list.assert_called_once_with(
+        self.volume_sdk_client.snapshots.assert_called_once_with(
             limit=None,
             marker=None,
-            search_opts={
-                'all_tenants': False,
-                'name': None,
-                'status': None,
-                'project_id': None,
-                'volume_id': self.volume.id,
-            },
+            all_projects=False,
+            name=None,
+            status=None,
+            project_id=None,
+            volume_id=self.volume.id,
         )
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, list(data))
@@ -497,16 +500,18 @@ class TestVolumeSnapshotList(TestVolumeSnapshot):
         )
 
 
-class TestVolumeSnapshotSet(TestVolumeSnapshot):
-    snapshot = volume_fakes.create_one_snapshot()
-
+class TestVolumeSnapshotSet(volume_fakes.TestVolume):
     def setUp(self):
         super().setUp()
 
-        self.snapshots_mock.get.return_value = self.snapshot
-        self.snapshots_mock.set_metadata.return_value = None
-        self.snapshots_mock.update.return_value = None
-        # Get the command object to mock
+        self.snapshot = sdk_fakes.generate_fake_resource(
+            _snapshot.Snapshot, metadata={'foo': 'bar'}
+        )
+        self.volume_sdk_client.find_snapshot.return_value = self.snapshot
+        self.volume_sdk_client.delete_snapshot_metadata.return_value = None
+        self.volume_sdk_client.set_snapshot_metadata.return_value = None
+        self.volume_sdk_client.update_snapshot.return_value = None
+
         self.cmd = volume_snapshot.SetVolumeSnapshot(self.app, None)
 
     def test_snapshot_set_no_option(self):
@@ -519,11 +524,14 @@ class TestVolumeSnapshotSet(TestVolumeSnapshot):
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
-        self.snapshots_mock.get.assert_called_once_with(parsed_args.snapshot)
-        self.assertNotCalled(self.snapshots_mock.reset_state)
-        self.assertNotCalled(self.snapshots_mock.update)
-        self.assertNotCalled(self.snapshots_mock.set_metadata)
+
         self.assertIsNone(result)
+        self.volume_sdk_client.find_snapshot.assert_called_once_with(
+            parsed_args.snapshot, ignore_missing=False
+        )
+        self.volume_sdk_client.reset_snapshot_status.assert_not_called()
+        self.volume_sdk_client.update_snapshot.assert_not_called()
+        self.volume_sdk_client.set_snapshot_metadata.assert_not_called()
 
     def test_snapshot_set_name_and_property(self):
         arglist = [
@@ -535,26 +543,22 @@ class TestVolumeSnapshotSet(TestVolumeSnapshot):
             "foo=foo",
             self.snapshot.id,
         ]
-        new_property = {"x": "y", "foo": "foo"}
         verifylist = [
             ("name", "new_snapshot"),
-            ("property", new_property),
+            ("properties", {"x": "y", "foo": "foo"}),
             ("snapshot", self.snapshot.id),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
 
-        kwargs = {
-            "name": "new_snapshot",
-        }
-        self.snapshots_mock.update.assert_called_with(
-            self.snapshot.id, **kwargs
+        self.assertIsNone(result)
+        self.volume_sdk_client.update_snapshot.assert_called_with(
+            self.snapshot.id, name="new_snapshot"
         )
-        self.snapshots_mock.set_metadata.assert_called_with(
-            self.snapshot.id, new_property
+        self.volume_sdk_client.set_snapshot_metadata.assert_called_with(
+            self.snapshot.id, x="y", foo="foo"
         )
-        self.assertIsNone(result)
 
     def test_snapshot_set_with_no_property(self):
         arglist = [
@@ -568,14 +572,17 @@ class TestVolumeSnapshotSet(TestVolumeSnapshot):
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
-        self.snapshots_mock.get.assert_called_once_with(parsed_args.snapshot)
-        self.assertNotCalled(self.snapshots_mock.reset_state)
-        self.assertNotCalled(self.snapshots_mock.update)
-        self.assertNotCalled(self.snapshots_mock.set_metadata)
-        self.snapshots_mock.delete_metadata.assert_called_with(
-            self.snapshot.id, ["foo"]
-        )
+
         self.assertIsNone(result)
+        self.volume_sdk_client.find_snapshot.assert_called_once_with(
+            parsed_args.snapshot, ignore_missing=False
+        )
+        self.volume_sdk_client.reset_snapshot_status.assert_not_called()
+        self.volume_sdk_client.update_snapshot.assert_not_called()
+        self.volume_sdk_client.set_snapshot_metadata.assert_not_called()
+        self.volume_sdk_client.delete_snapshot_metadata.assert_called_with(
+            self.snapshot.id, keys=["foo"]
+        )
 
     def test_snapshot_set_with_no_property_and_property(self):
         arglist = [
@@ -586,22 +593,26 @@ class TestVolumeSnapshotSet(TestVolumeSnapshot):
         ]
         verifylist = [
             ("no_property", True),
-            ("property", {"foo_1": "bar_1"}),
+            ("properties", {"foo_1": "bar_1"}),
             ("snapshot", self.snapshot.id),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
-        self.snapshots_mock.get.assert_called_once_with(parsed_args.snapshot)
-        self.assertNotCalled(self.snapshots_mock.reset_state)
-        self.assertNotCalled(self.snapshots_mock.update)
-        self.snapshots_mock.delete_metadata.assert_called_with(
-            self.snapshot.id, ["foo"]
+
+        self.assertIsNone(result)
+        self.volume_sdk_client.find_snapshot.assert_called_once_with(
+            parsed_args.snapshot, ignore_missing=False
         )
-        self.snapshots_mock.set_metadata.assert_called_once_with(
-            self.snapshot.id, {"foo_1": "bar_1"}
+        self.volume_sdk_client.reset_snapshot_status.assert_not_called()
+        self.volume_sdk_client.update_snapshot.assert_not_called()
+        self.volume_sdk_client.delete_snapshot_metadata.assert_called_with(
+            self.snapshot.id, keys=["foo"]
+        )
+        self.volume_sdk_client.set_snapshot_metadata.assert_called_once_with(
+            self.snapshot.id,
+            foo_1="bar_1",
         )
-        self.assertIsNone(result)
 
     def test_snapshot_set_state_to_error(self):
         arglist = ["--state", "error", self.snapshot.id]
@@ -610,30 +621,32 @@ class TestVolumeSnapshotSet(TestVolumeSnapshot):
 
         result = self.cmd.take_action(parsed_args)
 
-        self.snapshots_mock.reset_state.assert_called_with(
+        self.assertIsNone(result)
+        self.volume_sdk_client.reset_snapshot_status.assert_called_with(
             self.snapshot.id, "error"
         )
-        self.assertIsNone(result)
 
     def test_volume_set_state_failed(self):
-        self.snapshots_mock.reset_state.side_effect = exceptions.CommandError()
+        self.volume_sdk_client.reset_snapshot_status.side_effect = (
+            exceptions.CommandError()
+        )
         arglist = ['--state', 'error', self.snapshot.id]
         verifylist = [('state', 'error'), ('snapshot', self.snapshot.id)]
 
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        try:
-            self.cmd.take_action(parsed_args)
-            self.fail('CommandError should be raised.')
-        except exceptions.CommandError as e:
-            self.assertEqual(
-                'One or more of the set operations failed', str(e)
-            )
-        self.snapshots_mock.reset_state.assert_called_once_with(
+
+        exc = self.assertRaises(
+            exceptions.CommandError, self.cmd.take_action, parsed_args
+        )
+        self.assertEqual('One or more of the set operations failed', str(exc))
+        self.volume_sdk_client.reset_snapshot_status.assert_called_once_with(
             self.snapshot.id, 'error'
         )
 
     def test_volume_set_name_and_state_failed(self):
-        self.snapshots_mock.reset_state.side_effect = exceptions.CommandError()
+        self.volume_sdk_client.reset_snapshot_status.side_effect = (
+            exceptions.CommandError()
+        )
         arglist = [
             '--state',
             'error',
@@ -646,43 +659,39 @@ class TestVolumeSnapshotSet(TestVolumeSnapshot):
             ("name", "new_snapshot"),
             ('snapshot', self.snapshot.id),
         ]
-
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
-        try:
-            self.cmd.take_action(parsed_args)
-            self.fail('CommandError should be raised.')
-        except exceptions.CommandError as e:
-            self.assertEqual(
-                'One or more of the set operations failed', str(e)
-            )
-        kwargs = {
-            "name": "new_snapshot",
-        }
-        self.snapshots_mock.update.assert_called_once_with(
-            self.snapshot.id, **kwargs
+
+        exc = self.assertRaises(
+            exceptions.CommandError,
+            self.cmd.take_action,
+            parsed_args,
+        )
+
+        self.assertEqual('One or more of the set operations failed', str(exc))
+        self.volume_sdk_client.update_snapshot.assert_called_once_with(
+            self.snapshot.id, name="new_snapshot"
         )
-        self.snapshots_mock.reset_state.assert_called_once_with(
+        self.volume_sdk_client.reset_snapshot_status.assert_called_once_with(
             self.snapshot.id, 'error'
         )
 
 
-class TestVolumeSnapshotShow(TestVolumeSnapshot):
-    columns = (
-        'created_at',
-        'description',
-        'id',
-        'name',
-        'properties',
-        'size',
-        'status',
-        'volume_id',
-    )
-
+class TestVolumeSnapshotShow(volume_fakes.TestVolume):
     def setUp(self):
         super().setUp()
 
-        self.snapshot = volume_fakes.create_one_snapshot()
-
+        self.snapshot = sdk_fakes.generate_fake_resource(_snapshot.Snapshot)
+
+        self.columns = (
+            'created_at',
+            'description',
+            'id',
+            'name',
+            'properties',
+            'size',
+            'status',
+            'volume_id',
+        )
         self.data = (
             self.snapshot.created_at,
             self.snapshot.description,
@@ -694,8 +703,8 @@ class TestVolumeSnapshotShow(TestVolumeSnapshot):
             self.snapshot.volume_id,
         )
 
-        self.snapshots_mock.get.return_value = self.snapshot
-        # Get the command object to test
+        self.volume_sdk_client.find_snapshot.return_value = self.snapshot
+
         self.cmd = volume_snapshot.ShowVolumeSnapshot(self.app, None)
 
     def test_snapshot_show(self):
@@ -704,21 +713,22 @@ class TestVolumeSnapshotShow(TestVolumeSnapshot):
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         columns, data = self.cmd.take_action(parsed_args)
-        self.snapshots_mock.get.assert_called_with(self.snapshot.id)
+        self.volume_sdk_client.find_snapshot.assert_called_with(
+            self.snapshot.id, ignore_missing=False
+        )
 
         self.assertEqual(self.columns, columns)
         self.assertCountEqual(self.data, data)
 
 
-class TestVolumeSnapshotUnset(TestVolumeSnapshot):
-    snapshot = volume_fakes.create_one_snapshot()
-
+class TestVolumeSnapshotUnset(volume_fakes.TestVolume):
     def setUp(self):
         super().setUp()
 
-        self.snapshots_mock.get.return_value = self.snapshot
-        self.snapshots_mock.delete_metadata.return_value = None
-        # Get the command object to mock
+        self.snapshot = sdk_fakes.generate_fake_resource(_snapshot.Snapshot)
+        self.volume_sdk_client.find_snapshot.return_value = self.snapshot
+        self.volume_sdk_client.delete_snapshot_metadata.return_value = None
+
         self.cmd = volume_snapshot.UnsetVolumeSnapshot(self.app, None)
 
     def test_snapshot_unset(self):
@@ -728,7 +738,7 @@ class TestVolumeSnapshotUnset(TestVolumeSnapshot):
             self.snapshot.id,
         ]
         verifylist = [
-            ("property", ["foo"]),
+            ("properties", ["foo"]),
             ("snapshot", self.snapshot.id),
         ]
 
@@ -736,7 +746,7 @@ class TestVolumeSnapshotUnset(TestVolumeSnapshot):
 
         result = self.cmd.take_action(parsed_args)
 
-        self.snapshots_mock.delete_metadata.assert_called_with(
-            self.snapshot.id, ["foo"]
-        )
         self.assertIsNone(result)
+        self.volume_sdk_client.delete_snapshot_metadata.assert_called_with(
+            self.snapshot.id, keys=["foo"]
+        )