Merge "Add network segment create, delete and set support"

4 files changed, 392 insertions, 23 deletions

diff --git a/openstackclient/tests/functional/base.py b/openstackclient/tests/functional/base.py
index f7f0361e..298b2454 100644
--- a/openstackclient/tests/functional/base.py
+++ b/openstackclient/tests/functional/base.py
@@ -58,6 +58,11 @@ class TestCase(testtools.TestCase):
         return cls.openstack('configuration show ' + opts)
 
     @classmethod
+    def get_openstack_extention_names(cls):
+        opts = cls.get_opts(['Name'])
+        return cls.openstack('extension list ' + opts)
+
+    @classmethod
     def get_opts(cls, fields, format='value'):
         return ' -f {0} {1}'.format(format,
                                     ' '.join(['-c ' + it for it in fields]))
diff --git a/openstackclient/tests/functional/network/v2/test_network_segment.py b/openstackclient/tests/functional/network/v2/test_network_segment.py
index f871e88e..de5aef96 100644
--- a/openstackclient/tests/functional/network/v2/test_network_segment.py
+++ b/openstackclient/tests/functional/network/v2/test_network_segment.py
@@ -10,20 +10,18 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import testtools
 import uuid
 
 from openstackclient.tests.functional import base
 
 
-# NOTE(rtheis): Routed networks is still a WIP and not enabled by default.
-@testtools.skip("bp/routed-networks")
 class NetworkSegmentTests(base.TestCase):
     """Functional tests for network segment. """
     NETWORK_NAME = uuid.uuid4().hex
     PHYSICAL_NETWORK_NAME = uuid.uuid4().hex
     NETWORK_SEGMENT_ID = None
     NETWORK_ID = None
+    NETWORK_SEGMENT_EXTENSION = None
 
     @classmethod
     def setUpClass(cls):
@@ -32,29 +30,75 @@ class NetworkSegmentTests(base.TestCase):
         raw_output = cls.openstack('network create ' + cls.NETWORK_NAME + opts)
         cls.NETWORK_ID = raw_output.strip('\n')
 
-        # Get the segment for the network.
-        opts = cls.get_opts(['ID', 'Network'])
-        raw_output = cls.openstack('--os-beta-command '
-                                   'network segment list '
-                                   ' --network ' + cls.NETWORK_NAME +
-                                   ' ' + opts)
-        raw_output_row = raw_output.split('\n')[0]
-        cls.NETWORK_SEGMENT_ID = raw_output_row.split(' ')[0]
+        # NOTE(rtheis): The segment extension is not yet enabled by default.
+        # Skip the tests if not enabled.
+        extensions = cls.get_openstack_extention_names()
+        if 'Segment' in extensions:
+            cls.NETWORK_SEGMENT_EXTENSION = 'Segment'
+
+        if cls.NETWORK_SEGMENT_EXTENSION:
+            # Get the segment for the network.
+            opts = cls.get_opts(['ID', 'Network'])
+            raw_output = cls.openstack('--os-beta-command '
+                                       'network segment list '
+                                       ' --network ' + cls.NETWORK_NAME +
+                                       ' ' + opts)
+            raw_output_row = raw_output.split('\n')[0]
+            cls.NETWORK_SEGMENT_ID = raw_output_row.split(' ')[0]
 
     @classmethod
     def tearDownClass(cls):
         raw_output = cls.openstack('network delete ' + cls.NETWORK_NAME)
         cls.assertOutput('', raw_output)
 
+    def test_network_segment_create_delete(self):
+        if self.NETWORK_SEGMENT_EXTENSION:
+            opts = self.get_opts(['id'])
+            raw_output = self.openstack(
+                '--os-beta-command' +
+                ' network segment create --network ' + self.NETWORK_ID +
+                ' --network-type geneve ' +
+                ' --segment 2055 test_segment ' + opts
+            )
+            network_segment_id = raw_output.strip('\n')
+            raw_output = self.openstack('--os-beta-command ' +
+                                        'network segment delete ' +
+                                        network_segment_id)
+            self.assertOutput('', raw_output)
+        else:
+            self.skipTest('Segment extension disabled')
+
     def test_network_segment_list(self):
-        opts = self.get_opts(['ID'])
-        raw_output = self.openstack('--os-beta-command '
-                                    'network segment list' + opts)
-        self.assertIn(self.NETWORK_SEGMENT_ID, raw_output)
+        if self.NETWORK_SEGMENT_EXTENSION:
+            opts = self.get_opts(['ID'])
+            raw_output = self.openstack('--os-beta-command '
+                                        'network segment list' + opts)
+            self.assertIn(self.NETWORK_SEGMENT_ID, raw_output)
+        else:
+            self.skipTest('Segment extension disabled')
+
+    def test_network_segment_set(self):
+        if self.NETWORK_SEGMENT_EXTENSION:
+            new_description = 'new_description'
+            raw_output = self.openstack('--os-beta-command '
+                                        'network segment set ' +
+                                        '--description ' + new_description +
+                                        ' ' + self.NETWORK_SEGMENT_ID)
+            self.assertOutput('', raw_output)
+            opts = self.get_opts(['description'])
+            raw_output = self.openstack('--os-beta-command '
+                                        'network segment show ' +
+                                        self.NETWORK_SEGMENT_ID + opts)
+            self.assertEqual(new_description + "\n", raw_output)
+        else:
+            self.skipTest('Segment extension disabled')
 
     def test_network_segment_show(self):
-        opts = self.get_opts(['network_id'])
-        raw_output = self.openstack('--os-beta-command '
-                                    'network segment show ' +
-                                    self.NETWORK_SEGMENT_ID + opts)
-        self.assertEqual(self.NETWORK_ID + "\n", raw_output)
+        if self.NETWORK_SEGMENT_EXTENSION:
+            opts = self.get_opts(['network_id'])
+            raw_output = self.openstack('--os-beta-command '
+                                        'network segment show ' +
+                                        self.NETWORK_SEGMENT_ID + opts)
+            self.assertEqual(self.NETWORK_ID + "\n", raw_output)
+        else:
+            self.skipTest('Segment extension disabled')
diff --git a/openstackclient/tests/unit/network/v2/fakes.py b/openstackclient/tests/unit/network/v2/fakes.py
index 89b128ee..91aebf9f 100644
--- a/openstackclient/tests/unit/network/v2/fakes.py
+++ b/openstackclient/tests/unit/network/v2/fakes.py
@@ -364,11 +364,14 @@ class FakeNetworkSegment(object):
         attrs = attrs or {}
 
         # Set default attributes.
+        fake_uuid = uuid.uuid4().hex
         network_segment_attrs = {
-            'id': 'network-segment-id-' + uuid.uuid4().hex,
-            'network_id': 'network-id-' + uuid.uuid4().hex,
+            'description': 'network-segment-description-' + fake_uuid,
+            'id': 'network-segment-id-' + fake_uuid,
+            'name': 'network-segment-name-' + fake_uuid,
+            'network_id': 'network-id-' + fake_uuid,
             'network_type': 'vlan',
-            'physical_network': 'physical-network-name-' + uuid.uuid4().hex,
+            'physical_network': 'physical-network-name-' + fake_uuid,
             'segmentation_id': 1024,
         }
 
diff --git a/openstackclient/tests/unit/network/v2/test_network_segment.py b/openstackclient/tests/unit/network/v2/test_network_segment.py
index b9fce078..3e755e07 100644
--- a/openstackclient/tests/unit/network/v2/test_network_segment.py
+++ b/openstackclient/tests/unit/network/v2/test_network_segment.py
@@ -12,6 +12,7 @@
 #
 
 import mock
+from mock import call
 
 from osc_lib import exceptions
 
@@ -32,6 +33,243 @@ class TestNetworkSegment(network_fakes.TestNetworkV2):
         self.network = self.app.client_manager.network
 
 
+class TestCreateNetworkSegment(TestNetworkSegment):
+
+    # The network segment to create along with associated network.
+    _network_segment = \
+        network_fakes.FakeNetworkSegment.create_one_network_segment()
+    _network = network_fakes.FakeNetwork.create_one_network({
+        'id': _network_segment.network_id,
+    })
+
+    columns = (
+        'description',
+        'id',
+        'name',
+        'network_id',
+        'network_type',
+        'physical_network',
+        'segmentation_id',
+    )
+
+    data = (
+        _network_segment.description,
+        _network_segment.id,
+        _network_segment.name,
+        _network_segment.network_id,
+        _network_segment.network_type,
+        _network_segment.physical_network,
+        _network_segment.segmentation_id,
+    )
+
+    def setUp(self):
+        super(TestCreateNetworkSegment, self).setUp()
+
+        self.network.create_segment = mock.Mock(
+            return_value=self._network_segment
+        )
+        self.network.find_network = mock.Mock(return_value=self._network)
+
+        # Get the command object to test
+        self.cmd = network_segment.CreateNetworkSegment(
+            self.app,
+            self.namespace
+        )
+
+    def test_create_no_options(self):
+        # Missing required args should bail here
+        self.assertRaises(tests_utils.ParserException, self.check_parser,
+                          self.cmd, [], [])
+
+    def test_create_no_beta_commands(self):
+        arglist = [
+            '--network', self._network_segment.network_id,
+            '--network-type', self._network_segment.network_type,
+            self._network_segment.name,
+        ]
+        verifylist = [
+            ('network', self._network_segment.network_id),
+            ('network_type', self._network_segment.network_type),
+            ('name', self._network_segment.name),
+        ]
+        self.app.options.os_beta_command = False
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        self.assertRaises(exceptions.CommandError, self.cmd.take_action,
+                          parsed_args)
+
+    def test_create_invalid_network_type(self):
+        arglist = [
+            '--network', self._network_segment.network_id,
+            '--network-type', 'foo',
+            self._network_segment.name,
+        ]
+        self.assertRaises(tests_utils.ParserException, self.check_parser,
+                          self.cmd, arglist, [])
+
+    def test_create_minimum_options(self):
+        arglist = [
+            '--network', self._network_segment.network_id,
+            '--network-type', self._network_segment.network_type,
+            self._network_segment.name,
+        ]
+        verifylist = [
+            ('network', self._network_segment.network_id),
+            ('network_type', self._network_segment.network_type),
+            ('name', self._network_segment.name),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.network.find_network.assert_called_once_with(
+            self._network_segment.network_id,
+            ignore_missing=False
+        )
+        self.network.create_segment.assert_called_once_with(**{
+            'network_id': self._network_segment.network_id,
+            'network_type': self._network_segment.network_type,
+            'name': self._network_segment.name,
+        })
+
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
+
+    def test_create_all_options(self):
+        arglist = [
+            '--description', self._network_segment.description,
+            '--network', self._network_segment.network_id,
+            '--network-type', self._network_segment.network_type,
+            '--physical-network', self._network_segment.physical_network,
+            '--segment', str(self._network_segment.segmentation_id),
+            self._network_segment.name,
+        ]
+        verifylist = [
+            ('description', self._network_segment.description),
+            ('network', self._network_segment.network_id),
+            ('network_type', self._network_segment.network_type),
+            ('physical_network', self._network_segment.physical_network),
+            ('segment', self._network_segment.segmentation_id),
+            ('name', self._network_segment.name),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.network.find_network.assert_called_once_with(
+            self._network_segment.network_id,
+            ignore_missing=False
+        )
+        self.network.create_segment.assert_called_once_with(**{
+            'description': self._network_segment.description,
+            'network_id': self._network_segment.network_id,
+            'network_type': self._network_segment.network_type,
+            'physical_network': self._network_segment.physical_network,
+            'segmentation_id': self._network_segment.segmentation_id,
+            'name': self._network_segment.name,
+        })
+
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
+
+
+class TestDeleteNetworkSegment(TestNetworkSegment):
+
+    # The network segments to delete.
+    _network_segments = \
+        network_fakes.FakeNetworkSegment.create_network_segments()
+
+    def setUp(self):
+        super(TestDeleteNetworkSegment, self).setUp()
+
+        self.network.delete_segment = mock.Mock(return_value=None)
+        self.network.find_segment = mock.MagicMock(
+            side_effect=self._network_segments
+        )
+
+        # Get the command object to test
+        self.cmd = network_segment.DeleteNetworkSegment(
+            self.app,
+            self.namespace
+        )
+
+    def test_delete_no_beta_commands(self):
+        arglist = [
+            self._network_segments[0].id,
+        ]
+        verifylist = [
+            ('network_segment', [self._network_segments[0].id]),
+        ]
+        self.app.options.os_beta_command = False
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        self.assertRaises(exceptions.CommandError, self.cmd.take_action,
+                          parsed_args)
+
+    def test_delete(self):
+        arglist = [
+            self._network_segments[0].id,
+        ]
+        verifylist = [
+            ('network_segment', [self._network_segments[0].id]),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        result = self.cmd.take_action(parsed_args)
+
+        self.network.delete_segment.assert_called_once_with(
+            self._network_segments[0]
+        )
+        self.assertIsNone(result)
+
+    def test_delete_multiple(self):
+        arglist = []
+        for _network_segment in self._network_segments:
+            arglist.append(_network_segment.id)
+        verifylist = [
+            ('network_segment', arglist),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        result = self.cmd.take_action(parsed_args)
+
+        calls = []
+        for _network_segment in self._network_segments:
+            calls.append(call(_network_segment))
+        self.network.delete_segment.assert_has_calls(calls)
+        self.assertIsNone(result)
+
+    def test_delete_multiple_with_exception(self):
+        arglist = [
+            self._network_segments[0].id,
+            'doesnotexist'
+        ]
+        verifylist = [
+            ('network_segment', [self._network_segments[0].id,
+                                 'doesnotexist']),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+
+        find_mock_result = [self._network_segments[0],
+                            exceptions.CommandError]
+        self.network.find_segment = (
+            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 network segments failed to delete.',
+                             str(e))
+
+        self.network.find_segment.assert_any_call(
+            self._network_segments[0].id, ignore_missing=False)
+        self.network.find_segment.assert_any_call(
+            'doesnotexist', ignore_missing=False)
+        self.network.delete_segment.assert_called_once_with(
+            self._network_segments[0]
+        )
+
+
 class TestListNetworkSegment(TestNetworkSegment):
     _network = network_fakes.FakeNetwork.create_one_network()
     _network_segments = \
@@ -39,6 +277,7 @@ class TestListNetworkSegment(TestNetworkSegment):
 
     columns = (
         'ID',
+        'Name',
         'Network',
         'Network Type',
         'Segment',
@@ -51,6 +290,7 @@ class TestListNetworkSegment(TestNetworkSegment):
     for _network_segment in _network_segments:
         data.append((
             _network_segment.id,
+            _network_segment.name,
             _network_segment.network_id,
             _network_segment.network_type,
             _network_segment.segmentation_id,
@@ -60,6 +300,7 @@ class TestListNetworkSegment(TestNetworkSegment):
     for _network_segment in _network_segments:
         data_long.append((
             _network_segment.id,
+            _network_segment.name,
             _network_segment.network_id,
             _network_segment.network_type,
             _network_segment.segmentation_id,
@@ -131,6 +372,78 @@ class TestListNetworkSegment(TestNetworkSegment):
         self.assertEqual(self.data, list(data))
 
 
+class TestSetNetworkSegment(TestNetworkSegment):
+
+    # The network segment to show.
+    _network_segment = \
+        network_fakes.FakeNetworkSegment.create_one_network_segment()
+
+    def setUp(self):
+        super(TestSetNetworkSegment, self).setUp()
+
+        self.network.find_segment = mock.Mock(
+            return_value=self._network_segment
+        )
+        self.network.update_segment = mock.Mock(
+            return_value=self._network_segment
+        )
+
+        # Get the command object to test
+        self.cmd = network_segment.SetNetworkSegment(self.app, self.namespace)
+
+    def test_set_no_beta_commands(self):
+        arglist = [
+            self._network_segment.id,
+        ]
+        verifylist = [
+            ('network_segment', self._network_segment.id),
+        ]
+        self.app.options.os_beta_command = False
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        self.assertRaises(exceptions.CommandError, self.cmd.take_action,
+                          parsed_args)
+
+    def test_set_no_options(self):
+        arglist = [
+            self._network_segment.id,
+        ]
+        verifylist = [
+            ('network_segment', self._network_segment.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        self.network.update_segment.assert_called_once_with(
+            self._network_segment, **{}
+        )
+        self.assertIsNone(result)
+
+    def test_set_all_options(self):
+        arglist = [
+            '--description', 'new description',
+            '--name', 'new name',
+            self._network_segment.id,
+        ]
+        verifylist = [
+            ('description', 'new description'),
+            ('name', 'new name'),
+            ('network_segment', self._network_segment.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        attrs = {
+            'description': 'new description',
+            'name': 'new name',
+        }
+        self.network.update_segment.assert_called_once_with(
+            self._network_segment, **attrs
+        )
+        self.assertIsNone(result)
+
+
 class TestShowNetworkSegment(TestNetworkSegment):
 
     # The network segment to show.
@@ -138,7 +451,9 @@ class TestShowNetworkSegment(TestNetworkSegment):
         network_fakes.FakeNetworkSegment.create_one_network_segment()
 
     columns = (
+        'description',
         'id',
+        'name',
         'network_id',
         'network_type',
         'physical_network',
@@ -146,7 +461,9 @@ class TestShowNetworkSegment(TestNetworkSegment):
     )
 
     data = (
+        _network_segment.description,
         _network_segment.id,
+        _network_segment.name,
         _network_segment.network_id,
         _network_segment.network_type,
         _network_segment.physical_network,