Support error handling for delete commands in volumev2

Some delete conmmands in volumev2 did not support
error handling, this patch add them and also add
the unit tests for bulk deletion

Change-Id: I56ade6f9c7396c78fb989547476c4d94ccd76eae

Author: Huanxuan Ao

openstackclient/tests/volume/v2/fakes.py

@@ -418,6 +418,26 @@ def create_backups(attrs=None, count=2):
 
         return backups
 
+    @staticmethod
+    def get_backups(backups=None, count=2):
+        """Get an iterable MagicMock object with a list of faked backups.
+
+        If backups list is provided, then initialize the Mock object with the
+        list. Otherwise create one.
+
+        :param List volumes:
+            A list of FakeResource objects faking backups
+        :param Integer count:
+            The number of backups to be faked
+        :return
+            An iterable Mock object with side_effect set to a list of faked
+            backups
+        """
+        if backups is None:
+            backups = FakeBackup.create_backups(count)
+
+        return mock.MagicMock(side_effect=backups)
+
 
 class FakeExtension(object):
     """Fake one or more extension."""
@@ -529,6 +549,26 @@ def create_qoses(attrs=None, count=2):
 
         return qoses
 
+    @staticmethod
+    def get_qoses(qoses=None, count=2):
+        """Get an iterable MagicMock object with a list of faked qoses.
+
+        If qoses list is provided, then initialize the Mock object with the
+        list. Otherwise create one.
+
+        :param List volumes:
+            A list of FakeResource objects faking qoses
+        :param Integer count:
+            The number of qoses to be faked
+        :return
+            An iterable Mock object with side_effect set to a list of faked
+            qoses
+        """
+        if qoses is None:
+            qoses = FakeQos.create_qoses(count)
+
+        return mock.MagicMock(side_effect=qoses)
+
 
 class FakeSnapshot(object):
     """Fake one or more snapshot."""
@@ -582,6 +622,26 @@ def create_snapshots(attrs=None, count=2):
 
         return snapshots
 
+    @staticmethod
+    def get_snapshots(snapshots=None, count=2):
+        """Get an iterable MagicMock object with a list of faked snapshots.
+
+        If snapshots list is provided, then initialize the Mock object with the
+        list. Otherwise create one.
+
+        :param List volumes:
+            A list of FakeResource objects faking snapshots
+        :param Integer count:
+            The number of snapshots to be faked
+        :return
+            An iterable Mock object with side_effect set to a list of faked
+            snapshots
+        """
+        if snapshots is None:
+            snapshots = FakeSnapshot.create_snapshots(count)
+
+        return mock.MagicMock(side_effect=snapshots)
+
 
 class FakeType(object):
     """Fake one or more type."""

openstackclient/tests/volume/v2/test_backup.py

@@ -12,6 +12,12 @@
 #   under the License.
 #
 
+import mock
+from mock import call
+
+from osc_lib import exceptions
+from osc_lib import utils
+
 from openstackclient.tests.volume.v2 import fakes as volume_fakes
 from openstackclient.volume.v2 import backup
 
@@ -138,47 +144,95 @@ def test_backup_create_without_name(self):
 
 class TestBackupDelete(TestBackup):
 
-    backup = volume_fakes.FakeBackup.create_one_backup()
+    backups = volume_fakes.FakeBackup.create_backups(count=2)
 
     def setUp(self):
         super(TestBackupDelete, self).setUp()
 
-        self.backups_mock.get.return_value = self.backup
+        self.backups_mock.get = (
+            volume_fakes.FakeBackup.get_backups(self.backups))
         self.backups_mock.delete.return_value = None
 
         # Get the command object to mock
         self.cmd = backup.DeleteBackup(self.app, None)
 
     def test_backup_delete(self):
         arglist = [
-            self.backup.id
+            self.backups[0].id
         ]
         verifylist = [
-            ("backups", [self.backup.id])
+            ("backups", [self.backups[0].id])
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
 
-        self.backups_mock.delete.assert_called_with(self.backup.id, False)
+        self.backups_mock.delete.assert_called_with(
+            self.backups[0].id, False)
         self.assertIsNone(result)
 
     def test_backup_delete_with_force(self):
         arglist = [
             '--force',
-            self.backup.id,
+            self.backups[0].id,
         ]
         verifylist = [
             ('force', True),
-            ("backups", [self.backup.id])
+            ("backups", [self.backups[0].id])
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
 
-        self.backups_mock.delete.assert_called_with(self.backup.id, True)
+        self.backups_mock.delete.assert_called_with(self.backups[0].id, True)
         self.assertIsNone(result)
 
+    def test_delete_multiple_backups(self):
+        arglist = []
+        for b in self.backups:
+            arglist.append(b.id)
+        verifylist = [
+            ('backups', arglist),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        calls = []
+        for b in self.backups:
+            calls.append(call(b.id, False))
+        self.backups_mock.delete.assert_has_calls(calls)
+        self.assertIsNone(result)
+
+    def test_delete_multiple_backups_with_exception(self):
+        arglist = [
+            self.backups[0].id,
+            'unexist_backup',
+        ]
+        verifylist = [
+            ('backups', arglist),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        find_mock_result = [self.backups[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 backups failed to delete.',
+                                 str(e))
+
+            find_mock.assert_any_call(self.backups_mock, self.backups[0].id)
+            find_mock.assert_any_call(self.backups_mock, 'unexist_backup')
+
+            self.assertEqual(2, find_mock.call_count)
+            self.backups_mock.delete.assert_called_once_with(
+                self.backups[0].id, False
+            )
+
 
 class TestBackupList(TestBackup):
 

openstackclient/tests/volume/v2/test_qos_specs.py

@@ -13,6 +13,10 @@
 #   under the License.
 #
 
+import mock
+from mock import call
+
+from osc_lib import exceptions
 from osc_lib import utils
 
 from openstackclient.tests.volume.v2 import fakes as volume_fakes
@@ -156,45 +160,94 @@ def test_qos_create_with_properties(self):
 
 class TestQosDelete(TestQos):
 
-    qos_spec = volume_fakes.FakeQos.create_one_qos()
+    qos_specs = volume_fakes.FakeQos.create_qoses(count=2)
 
     def setUp(self):
         super(TestQosDelete, self).setUp()
 
-        self.qos_mock.get.return_value = self.qos_spec
+        self.qos_mock.get = (
+            volume_fakes.FakeQos.get_qoses(self.qos_specs))
         # Get the command object to test
         self.cmd = qos_specs.DeleteQos(self.app, None)
 
     def test_qos_delete(self):
         arglist = [
-            self.qos_spec.id
+            self.qos_specs[0].id
         ]
         verifylist = [
-            ('qos_specs', [self.qos_spec.id])
+            ('qos_specs', [self.qos_specs[0].id])
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
 
-        self.qos_mock.delete.assert_called_with(self.qos_spec.id, False)
+        self.qos_mock.delete.assert_called_with(
+            self.qos_specs[0].id, False)
         self.assertIsNone(result)
 
     def test_qos_delete_with_force(self):
         arglist = [
             '--force',
-            self.qos_spec.id
+            self.qos_specs[0].id
         ]
         verifylist = [
             ('force', True),
-            ('qos_specs', [self.qos_spec.id])
+            ('qos_specs', [self.qos_specs[0].id])
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
 
-        self.qos_mock.delete.assert_called_with(self.qos_spec.id, True)
+        self.qos_mock.delete.assert_called_with(
+            self.qos_specs[0].id, True)
         self.assertIsNone(result)
 
+    def test_delete_multiple_qoses(self):
+        arglist = []
+        for q in self.qos_specs:
+            arglist.append(q.id)
+        verifylist = [
+            ('qos_specs', arglist),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        calls = []
+        for q in self.qos_specs:
+            calls.append(call(q.id, False))
+        self.qos_mock.delete.assert_has_calls(calls)
+        self.assertIsNone(result)
+
+    def test_delete_multiple_qoses_with_exception(self):
+        arglist = [
+            self.qos_specs[0].id,
+            'unexist_qos',
+        ]
+        verifylist = [
+            ('qos_specs', arglist),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        find_mock_result = [self.qos_specs[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 QoS specifications failed to delete.', str(e))
+
+            find_mock.assert_any_call(self.qos_mock, self.qos_specs[0].id)
+            find_mock.assert_any_call(self.qos_mock, 'unexist_qos')
+
+            self.assertEqual(2, find_mock.call_count)
+            self.qos_mock.delete.assert_called_once_with(
+                self.qos_specs[0].id, False
+            )
+
 
 class TestQosDisassociate(TestQos):