Merge "Refactor security group delete to use SDK"

Author: Jenkins

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

@@ -2,7 +2,7 @@
 security group rule
 ===================
 
-Compute v2
+Compute v2, Network v2
 
 security group rule create
 --------------------------

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

@@ -2,7 +2,7 @@
 security group
 ==============
 
-Compute v2
+Compute v2, Network v2
 
 security group create
 ---------------------

openstackclient/compute/v2/security_group.py

@@ -169,28 +169,6 @@ def take_action(self, parsed_args):
         return zip(*sorted(six.iteritems(info)))
 
 
-class DeleteSecurityGroup(command.Command):
-    """Delete a security group"""
-
-    def get_parser(self, prog_name):
-        parser = super(DeleteSecurityGroup, self).get_parser(prog_name)
-        parser.add_argument(
-            'group',
-            metavar='<group>',
-            help='Security group to delete (name or ID)',
-        )
-        return parser
-
-    def take_action(self, parsed_args):
-
-        compute_client = self.app.client_manager.compute
-        data = utils.find_resource(
-            compute_client.security_groups,
-            parsed_args.group,
-        )
-        compute_client.security_groups.delete(data.id)
-
-
 class DeleteSecurityGroupRule(command.Command):
     """Delete a security group rule"""
 

openstackclient/network/common.py

@@ -0,0 +1,62 @@
+#   Licensed under the Apache License, Version 2.0 (the "License"); you may
+#   not use this file except in compliance with the License. You may obtain
+#   a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#   License for the specific language governing permissions and limitations
+#   under the License.
+#
+
+import abc
+import six
+
+from openstackclient.common import command
+
+
+@six.add_metaclass(abc.ABCMeta)
+class NetworkAndComputeCommand(command.Command):
+    """Network and Compute Command"""
+
+    def take_action(self, parsed_args):
+        if self.app.client_manager.is_network_endpoint_enabled():
+            return self.take_action_network(self.app.client_manager.network,
+                                            parsed_args)
+        else:
+            return self.take_action_compute(self.app.client_manager.compute,
+                                            parsed_args)
+
+    def get_parser(self, prog_name):
+        self.log.debug('get_parser(%s)', prog_name)
+        parser = super(NetworkAndComputeCommand, self).get_parser(prog_name)
+        parser = self.update_parser_common(parser)
+        self.log.debug('common parser: %s', parser)
+        if self.app.client_manager.is_network_endpoint_enabled():
+            return self.update_parser_network(parser)
+        else:
+            return self.update_parser_compute(parser)
+
+    def update_parser_common(self, parser):
+        """Default is no updates to parser."""
+        return parser
+
+    def update_parser_network(self, parser):
+        """Default is no updates to parser."""
+        return parser
+
+    def update_parser_compute(self, parser):
+        """Default is no updates to parser."""
+        return parser
+
+    @abc.abstractmethod
+    def take_action_network(self, client, parsed_args):
+        """Override to do something useful."""
+        pass
+
+    @abc.abstractmethod
+    def take_action_compute(self, client, parsed_args):
+        """Override to do something useful."""
+        pass

openstackclient/network/v2/security_group.py

@@ -0,0 +1,40 @@
+#   Licensed under the Apache License, Version 2.0 (the "License"); you may
+#   not use this file except in compliance with the License. You may obtain
+#   a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#   License for the specific language governing permissions and limitations
+#   under the License.
+#
+
+"""Security Group action implementations"""
+
+from openstackclient.common import utils
+from openstackclient.network import common
+
+
+class DeleteSecurityGroup(common.NetworkAndComputeCommand):
+    """Delete a security group"""
+
+    def update_parser_common(self, parser):
+        parser.add_argument(
+            'group',
+            metavar='<group>',
+            help='Security group to delete (name or ID)',
+        )
+        return parser
+
+    def take_action_network(self, client, parsed_args):
+        obj = client.find_security_group(parsed_args.group)
+        client.delete_security_group(obj)
+
+    def take_action_compute(self, client, parsed_args):
+        data = utils.find_resource(
+            client.security_groups,
+            parsed_args.group,
+        )
+        client.security_groups.delete(data.id)

openstackclient/tests/network/test_common.py

@@ -0,0 +1,103 @@
+#   Licensed under the Apache License, Version 2.0 (the "License"); you may
+#   not use this file except in compliance with the License. You may obtain
+#   a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#   WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#   License for the specific language governing permissions and limitations
+#   under the License.
+#
+
+import argparse
+import mock
+
+from openstackclient.network import common
+from openstackclient.tests import utils
+
+
+class FakeNetworkAndComputeCommand(common.NetworkAndComputeCommand):
+    def update_parser_common(self, parser):
+        parser.add_argument(
+            'common',
+            metavar='<common>',
+            help='Common argument',
+        )
+        return parser
+
+    def update_parser_network(self, parser):
+        parser.add_argument(
+            'network',
+            metavar='<network>',
+            help='Network argument',
+        )
+        return parser
+
+    def update_parser_compute(self, parser):
+        parser.add_argument(
+            'compute',
+            metavar='<compute>',
+            help='Compute argument',
+        )
+        return parser
+
+    def take_action_network(self, client, parsed_args):
+        client.network_action(parsed_args)
+        return 'take_action_network'
+
+    def take_action_compute(self, client, parsed_args):
+        client.compute_action(parsed_args)
+        return 'take_action_compute'
+
+
+class TestNetworkAndComputeCommand(utils.TestCommand):
+    def setUp(self):
+        super(TestNetworkAndComputeCommand, self).setUp()
+
+        self.namespace = argparse.Namespace()
+
+        # Create network client mocks.
+        self.app.client_manager.network = mock.Mock()
+        self.network = self.app.client_manager.network
+        self.network.network_action = mock.Mock(return_value=None)
+
+        # Create compute client mocks.
+        self.app.client_manager.compute = mock.Mock()
+        self.compute = self.app.client_manager.compute
+        self.compute.compute_action = mock.Mock(return_value=None)
+
+        # Get the command object to test
+        self.cmd = FakeNetworkAndComputeCommand(self.app, self.namespace)
+
+    def test_take_action_network(self):
+        arglist = [
+            'common',
+            'network'
+        ]
+        verifylist = [
+            ('common', 'common'),
+            ('network', 'network')
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+        self.network.network_action.assert_called_with(parsed_args)
+        self.assertEqual('take_action_network', result)
+
+    def test_take_action_compute(self):
+        arglist = [
+            'common',
+            'compute'
+        ]
+        verifylist = [
+            ('common', 'common'),
+            ('compute', 'compute')
+        ]
+
+        self.app.client_manager.network_endpoint_enabled = False
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+        self.compute.compute_action.assert_called_with(parsed_args)
+        self.assertEqual('take_action_compute', result)

openstackclient/tests/network/v2/fakes.py

@@ -356,6 +356,84 @@ def get_routers(routers=None, count=2):
         return mock.MagicMock(side_effect=routers)
 
 
+class FakeSecurityGroup(object):
+    """Fake one or more security groups."""
+
+    @staticmethod
+    def create_one_security_group(attrs={}, methods={}):
+        """Create a fake security group.
+
+        :param Dictionary attrs:
+            A dictionary with all attributes
+        :param Dictionary methods:
+            A dictionary with all methods
+        :return:
+            A FakeResource object, with id, name, etc.
+        """
+        # Set default attributes.
+        security_group_attrs = {
+            'id': 'security-group-id-' + uuid.uuid4().hex,
+            'name': 'security-group-name-' + uuid.uuid4().hex,
+            'description': 'security-group-description-' + uuid.uuid4().hex,
+            'tenant_id': 'project-id-' + uuid.uuid4().hex,
+            'security_group_rules': [],
+        }
+
+        # Overwrite default attributes.
+        security_group_attrs.update(attrs)
+
+        # Set default methods.
+        security_group_methods = {}
+
+        # Overwrite default methods.
+        security_group_methods.update(methods)
+
+        security_group = fakes.FakeResource(
+            info=copy.deepcopy(security_group_attrs),
+            methods=copy.deepcopy(security_group_methods),
+            loaded=True)
+        return security_group
+
+    @staticmethod
+    def create_security_groups(attrs={}, methods={}, count=2):
+        """Create multiple fake security groups.
+
+        :param Dictionary attrs:
+            A dictionary with all attributes
+        :param Dictionary methods:
+            A dictionary with all methods
+        :param int count:
+            The number of security groups to fake
+        :return:
+            A list of FakeResource objects faking the security groups
+        """
+        security_groups = []
+        for i in range(0, count):
+            security_groups.append(
+                FakeRouter.create_one_security_group(attrs, methods))
+
+        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 group 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 = FakeRouter.create_security_groups(count)
+        return mock.MagicMock(side_effect=security_groups)
+
+
 class FakeSubnet(object):
     """Fake one or more subnets."""