Support bulk deletion for commands that exist in both network and compute.

Some delete commands in networkv2 are exist in both network
and compute, They can use NetworkAndComputeDeleteclass to
supprot bulk deletion and error handling and the codes are
similar, so I change them all in this patch. The changed
commands including:
1.floating ip delete
2.security group delete
3.security group rule delete
Also, I update unit tests and docs for these commands in this patch.

Change-Id: I6c94c3d10ba579ddd9b14d17673c821e3481fd8a
Partially-Implements: blueprint multi-argument-network

doc/source/command-objects/ip-floating.rst

@@ -66,16 +66,17 @@ Create new floating IP address
 ip floating delete
 ------------------
 
-Delete floating IP
+Delete floating IP(s)
 
 .. program:: ip floating delete
 .. code:: bash
 
-    os ip floating delete <floating-ip>
+    os ip floating delete
+        <floating-ip> [<floating-ip> ...]
 
 .. describe:: <floating-ip>
 
-    Floating IP to delete (IP address or ID)
+    Floating IP(s) to delete (IP address or ID)
 
 ip floating list
 ----------------

doc/source/command-objects/security-group-rule.rst

@@ -104,17 +104,17 @@ Create a new security group rule
 security group rule delete
 --------------------------
 
-Delete a security group rule
+Delete security group rule(s)
 
 .. program:: security group rule delete
 .. code:: bash
 
     os security group rule delete
-        <rule>
+        <rule> [<rule> ...]
 
 .. describe:: <rule>
 
-    Security group rule to delete (ID only)
+    Security group rule(s) to delete (ID only)
 
 security group rule list
 ------------------------

doc/source/command-objects/security-group.rst

@@ -45,17 +45,17 @@ Create a new security group
 security group delete
 ---------------------
 
-Delete a security group
+Delete security group(s)
 
 .. program:: security group delete
 .. code:: bash
 
     os security group delete
-        <group>
+        <group> [<group> ...]
 
 .. describe:: <group>
 
-    Security group to delete (name or ID)
+    Security group(s) to delete (name or ID)
 
 security group list
 -------------------

openstackclient/network/v2/floating_ip.py

@@ -110,26 +110,28 @@ class CreateFloatingIP(common.NetworkAndComputeShowOne):
         return (columns, data)
 
 
-class DeleteFloatingIP(common.NetworkAndComputeCommand):
+class DeleteFloatingIP(common.NetworkAndComputeDelete):
-    """Delete floating IP"""
+    """Delete floating IP(s)"""
+
+    # Used by base class to find resources in parsed_args.
+    resource = 'floating_ip'
+    r = None
 
     def update_parser_common(self, parser):
         parser.add_argument(
             'floating_ip',
             metavar="<floating-ip>",
-            help=_("Floating IP to delete (IP address or ID)")
+            nargs="+",
+            help=_("Floating IP(s) to delete (IP address or ID)")
         )
         return parser
 
     def take_action_network(self, client, parsed_args):
-        obj = client.find_ip(parsed_args.floating_ip)
+        obj = client.find_ip(self.r, ignore_missing=False)
         client.delete_ip(obj)
 
     def take_action_compute(self, client, parsed_args):
-        obj = utils.find_resource(
+        obj = utils.find_resource(client.floating_ips, self.r)
-            client.floating_ips,
-            parsed_args.floating_ip,
-        )
         client.floating_ips.delete(obj.id)
 
 

openstackclient/network/v2/security_group.py

@@ -164,26 +164,28 @@ class CreateSecurityGroup(common.NetworkAndComputeShowOne):
         return (display_columns, data)
 
 
-class DeleteSecurityGroup(common.NetworkAndComputeCommand):
+class DeleteSecurityGroup(common.NetworkAndComputeDelete):
-    """Delete a security group"""
+    """Delete security group(s)"""
+
+    # Used by base class to find resources in parsed_args.
+    resource = 'group'
+    r = None
 
     def update_parser_common(self, parser):
         parser.add_argument(
             'group',
             metavar='<group>',
-            help=_("Security group to delete (name or ID)")
+            nargs="+",
+            help=_("Security group(s) to delete (name or ID)"),
         )
         return parser
 
     def take_action_network(self, client, parsed_args):
-        obj = client.find_security_group(parsed_args.group)
+        obj = client.find_security_group(self.r, ignore_missing=False)
         client.delete_security_group(obj)
 
     def take_action_compute(self, client, parsed_args):
-        data = utils.find_resource(
+        data = utils.find_resource(client.security_groups, self.r)
-            client.security_groups,
-            parsed_args.group,
-        )
         client.security_groups.delete(data.id)
 
 

openstackclient/network/v2/security_group_rule.py

@@ -333,23 +333,29 @@ class CreateSecurityGroupRule(common.NetworkAndComputeShowOne):
         return _format_security_group_rule_show(obj._info)
 
 
-class DeleteSecurityGroupRule(common.NetworkAndComputeCommand):
+class DeleteSecurityGroupRule(common.NetworkAndComputeDelete):
-    """Delete a security group rule"""
+    """Delete security group rule(s)"""
+
+    # Used by base class to find resources in parsed_args.
+    resource = 'rule'
+    r = None
 
     def update_parser_common(self, parser):
         parser.add_argument(
             'rule',
             metavar='<rule>',
-            help=_("Security group rule to delete (ID only)")
+            nargs="+",
+            help=_("Security group rule(s) to delete (ID only)")
         )
         return parser
 
     def take_action_network(self, client, parsed_args):
-        obj = client.find_security_group_rule(parsed_args.rule)
+        obj = client.find_security_group_rule(
+            self.r, ignore_missing=False)
         client.delete_security_group_rule(obj)
 
     def take_action_compute(self, client, parsed_args):
-        client.security_group_rules.delete(parsed_args.rule)
+        client.security_group_rules.delete(self.r)
 
 
 class ListSecurityGroupRule(common.NetworkAndComputeLister):

openstackclient/tests/compute/v2/fakes.py

@@ -452,6 +452,25 @@ class FakeSecurityGroup(object):
 
         return security_groups
 
+    @staticmethod
+    def get_security_groups(security_groups=None, count=2):
+        """Get an iterable MagicMock object with a list of faked security groups.
+
+        If security groups list is provided, then initialize the Mock object
+        with the list. Otherwise create one.
+
+        :param List security groups:
+            A list of FakeResource objects faking security groups
+        :param int count:
+            The number of security groups to fake
+        :return:
+            An iterable Mock object with side_effect set to a list of faked
+            security groups
+        """
+        if security_groups is None:
+            security_groups = FakeSecurityGroup.create_security_groups(count)
+        return mock.MagicMock(side_effect=security_groups)
+
 
 class FakeSecurityGroupRule(object):
     """Fake one or more security group rules."""

openstackclient/tests/network/v2/fakes.py

@@ -611,6 +611,25 @@ class FakeSecurityGroup(object):
 
         return security_groups
 
+    @staticmethod
+    def get_security_groups(security_groups=None, count=2):
+        """Get an iterable MagicMock object with a list of faked security groups.
+
+        If security groups list is provided, then initialize the Mock object
+        with the list. Otherwise create one.
+
+        :param List security groups:
+            A list of FakeResource objects faking security groups
+        :param int count:
+            The number of security groups to fake
+        :return:
+            An iterable Mock object with side_effect set to a list of faked
+            security groups
+        """
+        if security_groups is None:
+            security_groups = FakeSecurityGroup.create_security_groups(count)
+        return mock.MagicMock(side_effect=security_groups)
+
 
 class FakeSecurityGroupRule(object):
     """Fake one or more security group rules."""
@@ -670,6 +689,26 @@ class FakeSecurityGroupRule(object):
 
         return security_group_rules
 
+    @staticmethod
+    def get_security_group_rules(security_group_rules=None, count=2):
+        """Get an iterable MagicMock object with a list of faked security group rules.
+
+        If security group rules list is provided, then initialize the Mock
+        object with the list. Otherwise create one.
+
+        :param List security group rules:
+            A list of FakeResource objects faking security group rules
+        :param int count:
+            The number of security group rules to fake
+        :return:
+            An iterable Mock object with side_effect set to a list of faked
+            security group rules
+        """
+        if security_group_rules is None:
+            security_group_rules = (
+                FakeSecurityGroupRule.create_security_group_rules(count))
+        return mock.MagicMock(side_effect=security_group_rules)
+
 
 class FakeSubnet(object):
     """Fake one or more subnets."""

openstackclient/tests/network/v2/test_floating_ip.py

@@ -12,6 +12,9 @@
 #
 
 import mock
+from mock import call
+
+from osc_lib import exceptions
 
 from openstackclient.network.v2 import floating_ip
 from openstackclient.tests.compute.v2 import fakes as compute_fakes
@@ -140,33 +143,84 @@ class TestCreateFloatingIPNetwork(TestFloatingIPNetwork):
 
 class TestDeleteFloatingIPNetwork(TestFloatingIPNetwork):
 
-    # The floating ip to be deleted.
+    # The floating ips to be deleted.
-    floating_ip = network_fakes.FakeFloatingIP.create_one_floating_ip()
+    floating_ips = network_fakes.FakeFloatingIP.create_floating_ips(count=2)
 
     def setUp(self):
         super(TestDeleteFloatingIPNetwork, self).setUp()
 
         self.network.delete_ip = mock.Mock(return_value=None)
-        self.network.find_ip = mock.Mock(return_value=self.floating_ip)
+        self.network.find_ip = (
+            network_fakes.FakeFloatingIP.get_floating_ips(self.floating_ips))
 
         # Get the command object to test
         self.cmd = floating_ip.DeleteFloatingIP(self.app, self.namespace)
 
     def test_floating_ip_delete(self):
         arglist = [
-            self.floating_ip.id,
+            self.floating_ips[0].id,
         ]
         verifylist = [
-            ('floating_ip', self.floating_ip.id),
+            ('floating_ip', [self.floating_ips[0].id]),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
 
-        self.network.find_ip.assert_called_once_with(self.floating_ip.id)
+        self.network.find_ip.assert_called_once_with(
-        self.network.delete_ip.assert_called_once_with(self.floating_ip)
+            self.floating_ips[0].id, ignore_missing=False)
+        self.network.delete_ip.assert_called_once_with(self.floating_ips[0])
         self.assertIsNone(result)
 
+    def test_multi_floating_ips_delete(self):
+        arglist = []
+        verifylist = []
+
+        for f in self.floating_ips:
+            arglist.append(f.id)
+        verifylist = [
+            ('floating_ip', arglist),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        result = self.cmd.take_action(parsed_args)
+
+        calls = []
+        for f in self.floating_ips:
+            calls.append(call(f))
+        self.network.delete_ip.assert_has_calls(calls)
+        self.assertIsNone(result)
+
+    def test_multi_floating_ips_delete_with_exception(self):
+        arglist = [
+            self.floating_ips[0].id,
+            'unexist_floating_ip',
+        ]
+        verifylist = [
+            ('floating_ip',
+             [self.floating_ips[0].id, 'unexist_floating_ip']),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        find_mock_result = [self.floating_ips[0], exceptions.CommandError]
+        self.network.find_ip = (
+            mock.MagicMock(side_effect=find_mock_result)
+        )
+
+        try:
+            self.cmd.take_action(parsed_args)
+            self.fail('CommandError should be raised.')
+        except exceptions.CommandError as e:
+            self.assertEqual('1 of 2 floating_ip failed to delete.', str(e))
+
+        self.network.find_ip.assert_any_call(
+            self.floating_ips[0].id, ignore_missing=False)
+        self.network.find_ip.assert_any_call(
+            'unexist_floating_ip', ignore_missing=False)
+        self.network.delete_ip.assert_called_once_with(
+            self.floating_ips[0]
+        )
+
 
 class TestListFloatingIPNetwork(TestFloatingIPNetwork):
 
@@ -335,8 +389,8 @@ class TestCreateFloatingIPCompute(TestFloatingIPCompute):
 
 class TestDeleteFloatingIPCompute(TestFloatingIPCompute):
 
-    # The floating ip to be deleted.
+    # The floating ips to be deleted.
-    floating_ip = compute_fakes.FakeFloatingIP.create_one_floating_ip()
+    floating_ips = compute_fakes.FakeFloatingIP.create_floating_ips(count=2)
 
     def setUp(self):
         super(TestDeleteFloatingIPCompute, self).setUp()
@@ -346,27 +400,78 @@ class TestDeleteFloatingIPCompute(TestFloatingIPCompute):
         self.compute.floating_ips.delete.return_value = None
 
         # Return value of utils.find_resource()
-        self.compute.floating_ips.get.return_value = self.floating_ip
+        self.compute.floating_ips.get = (
+            compute_fakes.FakeFloatingIP.get_floating_ips(self.floating_ips))
 
         # Get the command object to test
         self.cmd = floating_ip.DeleteFloatingIP(self.app, None)
 
     def test_floating_ip_delete(self):
         arglist = [
-            self.floating_ip.id,
+            self.floating_ips[0].id,
         ]
         verifylist = [
-            ('floating_ip', self.floating_ip.id),
+            ('floating_ip', [self.floating_ips[0].id]),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
 
         self.compute.floating_ips.delete.assert_called_once_with(
-            self.floating_ip.id
+            self.floating_ips[0].id
         )
         self.assertIsNone(result)
 
+    def test_multi_floating_ips_delete(self):
+        arglist = []
+        verifylist = []
+
+        for f in self.floating_ips:
+            arglist.append(f.id)
+        verifylist = [
+            ('floating_ip', arglist),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        result = self.cmd.take_action(parsed_args)
+
+        calls = []
+        for f in self.floating_ips:
+            calls.append(call(f.id))
+        self.compute.floating_ips.delete.assert_has_calls(calls)
+        self.assertIsNone(result)
+
+    def test_multi_floating_ips_delete_with_exception(self):
+        arglist = [
+            self.floating_ips[0].id,
+            'unexist_floating_ip',
+        ]
+        verifylist = [
+            ('floating_ip',
+             [self.floating_ips[0].id, 'unexist_floating_ip']),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        find_mock_result = [self.floating_ips[0], exceptions.CommandError]
+        self.compute.floating_ips.get = (
+            mock.MagicMock(side_effect=find_mock_result)
+        )
+        self.compute.floating_ips.find.side_effect = exceptions.NotFound(None)
+
+        try:
+            self.cmd.take_action(parsed_args)
+            self.fail('CommandError should be raised.')
+        except exceptions.CommandError as e:
+            self.assertEqual('1 of 2 floating_ip failed to delete.', str(e))
+
+        self.compute.floating_ips.get.assert_any_call(
+            self.floating_ips[0].id)
+        self.compute.floating_ips.get.assert_any_call(
+            'unexist_floating_ip')
+        self.compute.floating_ips.delete.assert_called_once_with(
+            self.floating_ips[0].id
+        )
+
 
 class TestListFloatingIPCompute(TestFloatingIPCompute):
 

openstackclient/tests/network/v2/test_security_group.py

@@ -13,6 +13,9 @@
 
 import copy
 import mock
+from mock import call
+
+from osc_lib import exceptions
 
 from openstackclient.network.v2 import security_group
 from openstackclient.tests.compute.v2 import fakes as compute_fakes
@@ -227,42 +230,93 @@ class TestCreateSecurityGroupCompute(TestSecurityGroupCompute):
 
 class TestDeleteSecurityGroupNetwork(TestSecurityGroupNetwork):
 
-    # The security group to be deleted.
+    # The security groups to be deleted.
-    _security_group = \
+    _security_groups = \
-        network_fakes.FakeSecurityGroup.create_one_security_group()
+        network_fakes.FakeSecurityGroup.create_security_groups()
 
     def setUp(self):
         super(TestDeleteSecurityGroupNetwork, self).setUp()
 
         self.network.delete_security_group = mock.Mock(return_value=None)
 
-        self.network.find_security_group = mock.Mock(
+        self.network.find_security_group = (
-            return_value=self._security_group)
+            network_fakes.FakeSecurityGroup.get_security_groups(
+                self._security_groups)
+        )
 
         # Get the command object to test
         self.cmd = security_group.DeleteSecurityGroup(self.app, self.namespace)
 
     def test_security_group_delete(self):
         arglist = [
-            self._security_group.name,
+            self._security_groups[0].name,
         ]
         verifylist = [
-            ('group', self._security_group.name),
+            ('group', [self._security_groups[0].name]),
         ]
 
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
         result = self.cmd.take_action(parsed_args)
 
         self.network.delete_security_group.assert_called_once_with(
-            self._security_group)
+            self._security_groups[0])
         self.assertIsNone(result)
 
+    def test_multi_security_groups_delete(self):
+        arglist = []
+        verifylist = []
+
+        for s in self._security_groups:
+            arglist.append(s.name)
+        verifylist = [
+            ('group', arglist),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        result = self.cmd.take_action(parsed_args)
+
+        calls = []
+        for s in self._security_groups:
+            calls.append(call(s))
+        self.network.delete_security_group.assert_has_calls(calls)
+        self.assertIsNone(result)
+
+    def test_multi_security_groups_delete_with_exception(self):
+        arglist = [
+            self._security_groups[0].name,
+            'unexist_security_group',
+        ]
+        verifylist = [
+            ('group',
+             [self._security_groups[0].name, 'unexist_security_group']),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        find_mock_result = [self._security_groups[0], exceptions.CommandError]
+        self.network.find_security_group = (
+            mock.MagicMock(side_effect=find_mock_result)
+        )
+
+        try:
+            self.cmd.take_action(parsed_args)
+            self.fail('CommandError should be raised.')
+        except exceptions.CommandError as e:
+            self.assertEqual('1 of 2 group failed to delete.', str(e))
+
+        self.network.find_security_group.assert_any_call(
+            self._security_groups[0].name, ignore_missing=False)
+        self.network.find_security_group.assert_any_call(
+            'unexist_security_group', ignore_missing=False)
+        self.network.delete_security_group.assert_called_once_with(
+            self._security_groups[0]
+        )
+
 
 class TestDeleteSecurityGroupCompute(TestSecurityGroupCompute):
 
-    # The security group to be deleted.
+    # The security groups to be deleted.
-    _security_group = \
+    _security_groups = \
-        compute_fakes.FakeSecurityGroup.create_one_security_group()
+        compute_fakes.FakeSecurityGroup.create_security_groups()
 
     def setUp(self):
         super(TestDeleteSecurityGroupCompute, self).setUp()
@@ -271,27 +325,80 @@ class TestDeleteSecurityGroupCompute(TestSecurityGroupCompute):
 
         self.compute.security_groups.delete = mock.Mock(return_value=None)
 
-        self.compute.security_groups.get = mock.Mock(
+        self.compute.security_groups.get = (
-            return_value=self._security_group)
+            compute_fakes.FakeSecurityGroup.get_security_groups(
+                self._security_groups)
+        )
 
         # Get the command object to test
         self.cmd = security_group.DeleteSecurityGroup(self.app, None)
 
     def test_security_group_delete(self):
         arglist = [
-            self._security_group.name,
+            self._security_groups[0].id,
         ]
         verifylist = [
-            ('group', self._security_group.name),
+            ('group', [self._security_groups[0].id]),
         ]
 
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
         result = self.cmd.take_action(parsed_args)
 
         self.compute.security_groups.delete.assert_called_once_with(
-            self._security_group.id)
+            self._security_groups[0].id)
         self.assertIsNone(result)
 
+    def test_multi_security_groups_delete(self):
+        arglist = []
+        verifylist = []
+
+        for s in self._security_groups:
+            arglist.append(s.id)
+        verifylist = [
+            ('group', arglist),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        result = self.cmd.take_action(parsed_args)
+
+        calls = []
+        for s in self._security_groups:
+            calls.append(call(s.id))
+        self.compute.security_groups.delete.assert_has_calls(calls)
+        self.assertIsNone(result)
+
+    def test_multi_security_groups_delete_with_exception(self):
+        arglist = [
+            self._security_groups[0].id,
+            'unexist_security_group',
+        ]
+        verifylist = [
+            ('group',
+             [self._security_groups[0].id, 'unexist_security_group']),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        find_mock_result = [self._security_groups[0], exceptions.CommandError]
+        self.compute.security_groups.get = (
+            mock.MagicMock(side_effect=find_mock_result)
+        )
+        self.compute.security_groups.find.side_effect = (
+            exceptions.NotFound(None))
+
+        try:
+            self.cmd.take_action(parsed_args)
+            self.fail('CommandError should be raised.')
+        except exceptions.CommandError as e:
+            self.assertEqual('1 of 2 group failed to delete.', str(e))
+
+        self.compute.security_groups.get.assert_any_call(
+            self._security_groups[0].id)
+        self.compute.security_groups.get.assert_any_call(
+            'unexist_security_group')
+        self.compute.security_groups.delete.assert_called_once_with(
+            self._security_groups[0].id
+        )
+
 
 class TestListSecurityGroupNetwork(TestSecurityGroupNetwork):
 

openstackclient/tests/network/v2/test_security_group_rule.py

@@ -13,6 +13,7 @@
 
 import copy
 import mock
+from mock import call
 
 from osc_lib import exceptions
 
@@ -668,17 +669,20 @@ class TestCreateSecurityGroupRuleCompute(TestSecurityGroupRuleCompute):
 
 class TestDeleteSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
 
-    # The security group rule to be deleted.
+    # The security group rules to be deleted.
-    _security_group_rule = \
+    _security_group_rules = \
-        network_fakes.FakeSecurityGroupRule.create_one_security_group_rule()
+        network_fakes.FakeSecurityGroupRule.create_security_group_rules(
+            count=2)
 
     def setUp(self):
         super(TestDeleteSecurityGroupRuleNetwork, self).setUp()
 
         self.network.delete_security_group_rule = mock.Mock(return_value=None)
 
-        self.network.find_security_group_rule = mock.Mock(
+        self.network.find_security_group_rule = (
-            return_value=self._security_group_rule)
+            network_fakes.FakeSecurityGroupRule.get_security_group_rules(
+                self._security_group_rules)
+        )
 
         # Get the command object to test
         self.cmd = security_group_rule.DeleteSecurityGroupRule(
@@ -686,25 +690,76 @@ class TestDeleteSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
 
     def test_security_group_rule_delete(self):
         arglist = [
-            self._security_group_rule.id,
+            self._security_group_rules[0].id,
         ]
         verifylist = [
-            ('rule', self._security_group_rule.id),
+            ('rule', [self._security_group_rules[0].id]),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
 
         self.network.delete_security_group_rule.assert_called_once_with(
-            self._security_group_rule)
+            self._security_group_rules[0])
         self.assertIsNone(result)
 
+    def test_multi_security_group_rules_delete(self):
+        arglist = []
+        verifylist = []
+
+        for s in self._security_group_rules:
+            arglist.append(s.id)
+        verifylist = [
+            ('rule', arglist),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        result = self.cmd.take_action(parsed_args)
+
+        calls = []
+        for s in self._security_group_rules:
+            calls.append(call(s))
+        self.network.delete_security_group_rule.assert_has_calls(calls)
+        self.assertIsNone(result)
+
+    def test_multi_security_group_rules_delete_with_exception(self):
+        arglist = [
+            self._security_group_rules[0].id,
+            'unexist_rule',
+        ]
+        verifylist = [
+            ('rule',
+             [self._security_group_rules[0].id, 'unexist_rule']),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        find_mock_result = [
+            self._security_group_rules[0], exceptions.CommandError]
+        self.network.find_security_group_rule = (
+            mock.MagicMock(side_effect=find_mock_result)
+        )
+
+        try:
+            self.cmd.take_action(parsed_args)
+            self.fail('CommandError should be raised.')
+        except exceptions.CommandError as e:
+            self.assertEqual('1 of 2 rule failed to delete.', str(e))
+
+        self.network.find_security_group_rule.assert_any_call(
+            self._security_group_rules[0].id, ignore_missing=False)
+        self.network.find_security_group_rule.assert_any_call(
+            'unexist_rule', ignore_missing=False)
+        self.network.delete_security_group_rule.assert_called_once_with(
+            self._security_group_rules[0]
+        )
+
 
 class TestDeleteSecurityGroupRuleCompute(TestSecurityGroupRuleCompute):
 
     # The security group rule to be deleted.
-    _security_group_rule = \
+    _security_group_rules = \
-        compute_fakes.FakeSecurityGroupRule.create_one_security_group_rule()
+        compute_fakes.FakeSecurityGroupRule.create_security_group_rules(
+            count=2)
 
     def setUp(self):
         super(TestDeleteSecurityGroupRuleCompute, self).setUp()
@@ -716,19 +771,65 @@ class TestDeleteSecurityGroupRuleCompute(TestSecurityGroupRuleCompute):
 
     def test_security_group_rule_delete(self):
         arglist = [
-            self._security_group_rule.id,
+            self._security_group_rules[0].id,
         ]
         verifylist = [
-            ('rule', self._security_group_rule.id),
+            ('rule', [self._security_group_rules[0].id]),
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
 
         self.compute.security_group_rules.delete.assert_called_once_with(
-            self._security_group_rule.id)
+            self._security_group_rules[0].id)
         self.assertIsNone(result)
 
+    def test_multi_security_group_rules_delete(self):
+        arglist = []
+        verifylist = []
+
+        for s in self._security_group_rules:
+            arglist.append(s.id)
+        verifylist = [
+            ('rule', arglist),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        result = self.cmd.take_action(parsed_args)
+
+        calls = []
+        for s in self._security_group_rules:
+            calls.append(call(s.id))
+        self.compute.security_group_rules.delete.assert_has_calls(calls)
+        self.assertIsNone(result)
+
+    def test_multi_security_group_rules_delete_with_exception(self):
+        arglist = [
+            self._security_group_rules[0].id,
+            'unexist_rule',
+        ]
+        verifylist = [
+            ('rule',
+             [self._security_group_rules[0].id, 'unexist_rule']),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        find_mock_result = [None, exceptions.CommandError]
+        self.compute.security_group_rules.delete = (
+            mock.MagicMock(side_effect=find_mock_result)
+        )
+
+        try:
+            self.cmd.take_action(parsed_args)
+            self.fail('CommandError should be raised.')
+        except exceptions.CommandError as e:
+            self.assertEqual('1 of 2 rule failed to delete.', str(e))
+
+        self.compute.security_group_rules.delete.assert_any_call(
+            self._security_group_rules[0].id)
+        self.compute.security_group_rules.delete.assert_any_call(
+            'unexist_rule')
+
 
 class TestListSecurityGroupRuleNetwork(TestSecurityGroupRuleNetwork):
 

releasenotes/notes/bp-multi-argument-network-e43e192ac95db94d.yaml

@@ -0,0 +1,5 @@
+---
+features:
+  - Support bulk deletion for ``floating ip delete``, ``security group delete``,
+    and ``security group rule delete`` commands in networkv2.
+    [Blueprint `multi-argument-network <https://blueprints.launchpad.net/python-openstackclient/+spec/multi-argument-network>`_]