Merge "Network tag support"

8 files changed, 526 insertions, 85 deletions

diff --git a/openstackclient/tests/unit/network/v2/_test_tag.py b/openstackclient/tests/unit/network/v2/_test_tag.py
new file mode 100644
index 00000000..bd461537
--- /dev/null
+++ b/openstackclient/tests/unit/network/v2/_test_tag.py
@@ -0,0 +1,190 @@
+#   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.
+#
+
+from openstackclient.tests.unit import utils as tests_utils
+
+
+class TestCreateTagMixin(object):
+    """Test case mixin to test network tag operation for resource creation.
+
+    * Each test class must create a mock for self.network.set_tags
+    * If you test tag operation combined with other options,
+      you need to write test(s) directly in individual test cases.
+    * The following instance attributes must be defined:
+
+      * _tag_test_resource: Test resource returned by mocked create_<resource>.
+      * _tag_create_resource_mock: Mocked create_<resource> method of SDK.
+      * _tag_create_required_arglist: List of required arguments when creating
+          a resource with default options.
+      * _tag_create_required_verifylist: List of expected parsed_args params
+          when creating a resource with default options.
+      * _tag_create_required_attrs: Expected attributes passed to a mocked
+          create_resource method when creating a resource with default options.
+    """
+
+    def _test_create_with_tag(self, add_tags=True):
+        arglist = self._tag_create_required_arglist[:]
+        if add_tags:
+            arglist += ['--tag', 'red', '--tag', 'blue']
+        else:
+            arglist += ['--no-tag']
+        verifylist = self._tag_create_required_verifylist[:]
+        if add_tags:
+            verifylist.append(('tags', ['red', 'blue']))
+        else:
+            verifylist.append(('no_tag', True))
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        columns, data = (self.cmd.take_action(parsed_args))
+
+        self._tag_create_resource_mock.assert_called_once_with(
+            **self._tag_create_required_attrs)
+        if add_tags:
+            self.network.set_tags.assert_called_once_with(
+                self._tag_test_resource,
+                tests_utils.CompareBySet(['red', 'blue']))
+        else:
+            self.assertFalse(self.network.set_tags.called)
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
+
+    def test_create_with_tags(self):
+        self._test_create_with_tag(add_tags=True)
+
+    def test_create_with_no_tag(self):
+        self._test_create_with_tag(add_tags=False)
+
+
+class TestListTagMixin(object):
+    """Test case mixin to test network tag operation for resource listing.
+
+    * A test resource returned by find_<resource> must contains
+      "red" and "green" tags.
+    * Each test class must create a mock for self.network.set_tags
+    * If you test tag operation combined with other options,
+      you need to write test(s) directly in individual test cases.
+    * The following instance attributes must be defined:
+
+      * _tag_create_resource_mock: Mocked list_<resource> method of SDK.
+    """
+
+    def test_list_with_tag_options(self):
+        arglist = [
+            '--tags', 'red,blue',
+            '--any-tags', 'red,green',
+            '--not-tags', 'orange,yellow',
+            '--not-any-tags', 'black,white',
+        ]
+        verifylist = [
+            ('tags', ['red', 'blue']),
+            ('any_tags', ['red', 'green']),
+            ('not_tags', ['orange', 'yellow']),
+            ('not_any_tags', ['black', 'white']),
+        ]
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self._tag_list_resource_mock.assert_called_once_with(
+            **{'tags': 'red,blue',
+               'any_tags': 'red,green',
+               'not_tags': 'orange,yellow',
+               'not_any_tags': 'black,white'}
+        )
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, list(data))
+
+
+class TestSetTagMixin(object):
+    """Test case mixin to test network tag operation for resource update.
+
+    * A test resource returned by find_<resource> must contains
+      "red" and "green" tags.
+    * Each test class must create a mock for self.network.set_tags
+    * If you test tag operation combined with other options,
+      you need to write test(s) directly in individual test cases.
+    * The following instance attributes must be defined:
+
+      * _tag_resource_name: positional arg name of a resource to be updated.
+      * _tag_test_resource: Test resource returned by mocked update_<resource>.
+      * _tag_update_resource_mock: Mocked update_<resource> method of SDK.
+    """
+
+    def _test_set_tags(self, with_tags=True):
+        if with_tags:
+            arglist = ['--tag', 'red', '--tag', 'blue']
+            verifylist = [('tags', ['red', 'blue'])]
+            expected_args = ['red', 'blue', 'green']
+        else:
+            arglist = ['--no-tag']
+            verifylist = [('no_tag', True)]
+            expected_args = []
+        arglist.append(self._tag_test_resource.name)
+        verifylist.append(
+            (self._tag_resource_name, self._tag_test_resource.name))
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        self.assertFalse(self._tag_update_resource_mock.called)
+        self.network.set_tags.assert_called_once_with(
+            self._tag_test_resource,
+            tests_utils.CompareBySet(expected_args))
+        self.assertIsNone(result)
+
+    def test_set_with_tags(self):
+        self._test_set_tags(with_tags=True)
+
+    def test_set_with_no_tag(self):
+        self._test_set_tags(with_tags=False)
+
+
+class TestUnsetTagMixin(object):
+    """Test case mixin to test network tag operation for resource update.
+
+    * Each test class must create a mock for self.network.set_tags
+    * If you test tag operation combined with other options,
+      you need to write test(s) directly in individual test cases.
+    * The following instance attributes must be defined:
+
+      * _tag_resource_name: positional arg name of a resource to be updated.
+      * _tag_test_resource: Test resource returned by mocked update_<resource>.
+      * _tag_update_resource_mock: Mocked update_<resource> method of SDK.
+    """
+
+    def _test_unset_tags(self, with_tags=True):
+        if with_tags:
+            arglist = ['--tag', 'red', '--tag', 'blue']
+            verifylist = [('tags', ['red', 'blue'])]
+            expected_args = ['green']
+        else:
+            arglist = ['--all-tag']
+            verifylist = [('all_tag', True)]
+            expected_args = []
+        arglist.append(self._tag_test_resource.name)
+        verifylist.append(
+            (self._tag_resource_name, self._tag_test_resource.name))
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        self.assertFalse(self._tag_update_resource_mock.called)
+        self.network.set_tags.assert_called_once_with(
+            self._tag_test_resource,
+            tests_utils.CompareBySet(expected_args))
+        self.assertIsNone(result)
+
+    def test_unset_with_tags(self):
+        self._test_unset_tags(with_tags=True)
+
+    def test_unset_with_all_tag(self):
+        self._test_unset_tags(with_tags=False)
diff --git a/openstackclient/tests/unit/network/v2/fakes.py b/openstackclient/tests/unit/network/v2/fakes.py
index 98bda164..eadab584 100644
--- a/openstackclient/tests/unit/network/v2/fakes.py
+++ b/openstackclient/tests/unit/network/v2/fakes.py
@@ -350,6 +350,7 @@ class FakeNetwork(object):
             'qos_policy_id': 'qos-policy-id-' + uuid.uuid4().hex,
             'ipv4_address_scope': 'ipv4' + uuid.uuid4().hex,
             'ipv6_address_scope': 'ipv6' + uuid.uuid4().hex,
+            'tags': [],
         }
 
         # Overwrite default attributes.
@@ -576,6 +577,7 @@ class FakePort(object):
             'status': 'ACTIVE',
             'tenant_id': 'project-id-' + uuid.uuid4().hex,
             'qos_policy_id': 'qos-policy-id-' + uuid.uuid4().hex,
+            'tags': [],
         }
 
         # Overwrite default attributes.
@@ -1053,6 +1055,7 @@ class FakeRouter(object):
             'external_gateway_info': {},
             'availability_zone_hints': [],
             'availability_zones': [],
+            'tags': [],
         }
 
         # Overwrite default attributes.
@@ -1294,6 +1297,7 @@ class FakeSubnet(object):
             'service_types': [],
             'subnetpool_id': None,
             'description': 'subnet-description-' + uuid.uuid4().hex,
+            'tags': [],
         }
 
         # Overwrite default attributes.
@@ -1544,6 +1548,7 @@ class FakeSubnetPool(object):
             'default_quota': None,
             'ip_version': '4',
             'description': 'subnet-pool-description-' + uuid.uuid4().hex,
+            'tags': [],
         }
 
         # Overwrite default attributes.
diff --git a/openstackclient/tests/unit/network/v2/test_network.py b/openstackclient/tests/unit/network/v2/test_network.py
index bc8c4024..e620cd9c 100644
--- a/openstackclient/tests/unit/network/v2/test_network.py
+++ b/openstackclient/tests/unit/network/v2/test_network.py
@@ -22,6 +22,7 @@ from openstackclient.network.v2 import network
 from openstackclient.tests.unit import fakes
 from openstackclient.tests.unit.identity.v2_0 import fakes as identity_fakes_v2
 from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes_v3
+from openstackclient.tests.unit.network.v2 import _test_tag
 from openstackclient.tests.unit.network.v2 import fakes as network_fakes
 from openstackclient.tests.unit import utils as tests_utils
 
@@ -41,7 +42,7 @@ class TestNetwork(network_fakes.TestNetworkV2):
         self.domains_mock = self.app.client_manager.identity.domains
 
 
-class TestCreateNetworkIdentityV3(TestNetwork):
+class TestCreateNetworkIdentityV3(TestNetwork, _test_tag.TestCreateTagMixin):
 
     project = identity_fakes_v3.FakeProject.create_one_project()
     domain = identity_fakes_v3.FakeDomain.create_one_domain()
@@ -105,6 +106,7 @@ class TestCreateNetworkIdentityV3(TestNetwork):
         super(TestCreateNetworkIdentityV3, self).setUp()
 
         self.network.create_network = mock.Mock(return_value=self._network)
+        self.network.set_tags = mock.Mock(return_value=None)
 
         # Get the command object to test
         self.cmd = network.CreateNetwork(self.app, self.namespace)
@@ -113,6 +115,22 @@ class TestCreateNetworkIdentityV3(TestNetwork):
         self.domains_mock.get.return_value = self.domain
         self.network.find_qos_policy = mock.Mock(return_value=self.qos_policy)
 
+        # TestCreateTagMixin
+        self._tag_test_resource = self._network
+        self._tag_create_resource_mock = self.network.create_network
+        self._tag_create_required_arglist = [self._network.name]
+        self._tag_create_required_verifylist = [
+            ('name', self._network.name),
+            ('enable', True),
+            ('share', None),
+            ('project', None),
+            ('external', False),
+        ]
+        self._tag_create_required_attrs = {
+            'admin_state_up': True,
+            'name': self._network.name,
+        }
+
     def test_create_no_options(self):
         arglist = []
         verifylist = []
@@ -139,6 +157,7 @@ class TestCreateNetworkIdentityV3(TestNetwork):
             'admin_state_up': True,
             'name': self._network.name,
         })
+        self.assertFalse(self.network.set_tags.called)
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, data)
 
@@ -287,6 +306,7 @@ class TestCreateNetworkIdentityV2(TestNetwork):
         super(TestCreateNetworkIdentityV2, self).setUp()
 
         self.network.create_network = mock.Mock(return_value=self._network)
+        self.network.set_tags = mock.Mock(return_value=None)
 
         # Get the command object to test
         self.cmd = network.CreateNetwork(self.app, self.namespace)
@@ -328,6 +348,7 @@ class TestCreateNetworkIdentityV2(TestNetwork):
             'tenant_id': self.project.id,
             'project_id': self.project.id,
         })
+        self.assertFalse(self.network.set_tags.called)
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, data)
 
@@ -440,7 +461,7 @@ class TestDeleteNetwork(TestNetwork):
         self.network.delete_network.assert_has_calls(calls)
 
 
-class TestListNetwork(TestNetwork):
+class TestListNetwork(TestNetwork, _test_tag.TestListTagMixin):
 
     # The networks going to be listed up.
     _network = network_fakes.FakeNetwork.create_networks(count=3)
@@ -461,6 +482,7 @@ class TestListNetwork(TestNetwork):
         'Network Type',
         'Router Type',
         'Availability Zones',
+        'Tags',
     )
 
     data = []
@@ -484,6 +506,7 @@ class TestListNetwork(TestNetwork):
             net.provider_network_type,
             network._format_router_external(net.is_router_external),
             utils.format_list(net.availability_zones),
+            utils.format_list(net.tags),
         ))
 
     def setUp(self):
@@ -501,6 +524,9 @@ class TestListNetwork(TestNetwork):
         self.network.dhcp_agent_hosting_networks = mock.Mock(
             return_value=self._network)
 
+        # TestListTagMixin
+        self._tag_list_resource_mock = self.network.networks
+
     def test_network_list_no_options(self):
         arglist = []
         verifylist = [
@@ -795,10 +821,11 @@ class TestListNetwork(TestNetwork):
         self.assertEqual(list(data), list(self.data))
 
 
-class TestSetNetwork(TestNetwork):
+class TestSetNetwork(TestNetwork, _test_tag.TestSetTagMixin):
 
     # The network to set.
-    _network = network_fakes.FakeNetwork.create_one_network()
+    _network = network_fakes.FakeNetwork.create_one_network(
+        {'tags': ['green', 'red']})
     qos_policy = (network_fakes.FakeNetworkQosPolicy.
                   create_one_qos_policy(attrs={'id': _network.qos_policy_id}))
 
@@ -806,6 +833,7 @@ class TestSetNetwork(TestNetwork):
         super(TestSetNetwork, self).setUp()
 
         self.network.update_network = mock.Mock(return_value=None)
+        self.network.set_tags = mock.Mock(return_value=None)
 
         self.network.find_network = mock.Mock(return_value=self._network)
         self.network.find_qos_policy = mock.Mock(return_value=self.qos_policy)
@@ -813,6 +841,11 @@ class TestSetNetwork(TestNetwork):
         # Get the command object to test
         self.cmd = network.SetNetwork(self.app, self.namespace)
 
+        # TestSetTagMixin
+        self._tag_resource_name = 'network'
+        self._tag_test_resource = self._network
+        self._tag_update_resource_mock = self.network.update_network
+
     def test_set_this(self):
         arglist = [
             self._network.name,
@@ -902,9 +935,8 @@ class TestSetNetwork(TestNetwork):
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
         result = self.cmd.take_action(parsed_args)
 
-        attrs = {}
-        self.network.update_network.assert_called_once_with(
-            self._network, **attrs)
+        self.assertFalse(self.network.update_network.called)
+        self.assertFalse(self.network.set_tags.called)
         self.assertIsNone(result)
 
 
@@ -990,3 +1022,40 @@ class TestShowNetwork(TestNetwork):
 
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, data)
+
+
+class TestUnsetNetwork(TestNetwork, _test_tag.TestUnsetTagMixin):
+
+    # The network to set.
+    _network = network_fakes.FakeNetwork.create_one_network(
+        {'tags': ['green', 'red']})
+    qos_policy = (network_fakes.FakeNetworkQosPolicy.
+                  create_one_qos_policy(attrs={'id': _network.qos_policy_id}))
+
+    def setUp(self):
+        super(TestUnsetNetwork, self).setUp()
+
+        self.network.update_network = mock.Mock(return_value=None)
+        self.network.set_tags = mock.Mock(return_value=None)
+
+        self.network.find_network = mock.Mock(return_value=self._network)
+        self.network.find_qos_policy = mock.Mock(return_value=self.qos_policy)
+
+        # Get the command object to test
+        self.cmd = network.UnsetNetwork(self.app, self.namespace)
+
+        # TestUnsetNetwork
+        self._tag_resource_name = 'network'
+        self._tag_test_resource = self._network
+        self._tag_update_resource_mock = self.network.update_network
+
+    def test_unset_nothing(self):
+        arglist = [self._network.name, ]
+        verifylist = [('network', self._network.name), ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        self.assertFalse(self.network.update_network.called)
+        self.assertFalse(self.network.set_tags.called)
+        self.assertIsNone(result)
diff --git a/openstackclient/tests/unit/network/v2/test_port.py b/openstackclient/tests/unit/network/v2/test_port.py
index a8a6dba9..deda6b41 100644
--- a/openstackclient/tests/unit/network/v2/test_port.py
+++ b/openstackclient/tests/unit/network/v2/test_port.py
@@ -21,6 +21,7 @@ from osc_lib import utils
 from openstackclient.network.v2 import port
 from openstackclient.tests.unit.compute.v2 import fakes as compute_fakes
 from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes
+from openstackclient.tests.unit.network.v2 import _test_tag
 from openstackclient.tests.unit.network.v2 import fakes as network_fakes
 from openstackclient.tests.unit import utils as tests_utils
 
@@ -35,7 +36,8 @@ class TestPort(network_fakes.TestNetworkV2):
         # Get a shortcut to the ProjectManager Mock
         self.projects_mock = self.app.client_manager.identity.projects
 
-    def _get_common_cols_data(self, fake_port):
+    @staticmethod
+    def _get_common_cols_data(fake_port):
         columns = (
             'admin_state_up',
             'allowed_address_pairs',
@@ -61,6 +63,7 @@ class TestPort(network_fakes.TestNetworkV2):
             'qos_policy_id',
             'security_group_ids',
             'status',
+            'tags',
         )
 
         data = (
@@ -88,19 +91,22 @@ class TestPort(network_fakes.TestNetworkV2):
             fake_port.qos_policy_id,
             utils.format_list(fake_port.security_group_ids),
             fake_port.status,
+            utils.format_list(fake_port.tags),
         )
 
         return columns, data
 
 
-class TestCreatePort(TestPort):
+class TestCreatePort(TestPort, _test_tag.TestCreateTagMixin):
 
     _port = network_fakes.FakePort.create_one_port()
+    columns, data = TestPort._get_common_cols_data(_port)
 
     def setUp(self):
         super(TestCreatePort, self).setUp()
 
         self.network.create_port = mock.Mock(return_value=self._port)
+        self.network.set_tags = mock.Mock(return_value=None)
         fake_net = network_fakes.FakeNetwork.create_one_network({
             'id': self._port.network_id,
         })
@@ -110,6 +116,24 @@ class TestCreatePort(TestPort):
         # Get the command object to test
         self.cmd = port.CreatePort(self.app, self.namespace)
 
+        # TestUnsetTagMixin
+        self._tag_test_resource = self._port
+        self._tag_create_resource_mock = self.network.create_port
+        self._tag_create_required_arglist = [
+            '--network', self._port.network_id,
+            'test-port',
+        ]
+        self._tag_create_required_verifylist = [
+            ('network', self._port.network_id,),
+            ('enable', True),
+            ('name', 'test-port'),
+        ]
+        self._tag_create_required_attrs = {
+            'admin_state_up': True,
+            'network_id': self._port.network_id,
+            'name': 'test-port',
+        }
+
     def test_create_default_options(self):
         arglist = [
             '--network', self._port.network_id,
@@ -129,10 +153,10 @@ class TestCreatePort(TestPort):
             'network_id': self._port.network_id,
             'name': 'test-port',
         })
+        self.assertFalse(self.network.set_tags.called)
 
-        ref_columns, ref_data = self._get_common_cols_data(self._port)
-        self.assertEqual(ref_columns, columns)
-        self.assertEqual(ref_data, data)
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
 
     def test_create_full_options(self):
         arglist = [
@@ -166,7 +190,6 @@ class TestCreatePort(TestPort):
             ('network', self._port.network_id),
             ('dns_name', '8.8.8.8'),
             ('name', 'test-port'),
-
         ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
@@ -187,9 +210,8 @@ class TestCreatePort(TestPort):
             'name': 'test-port',
         })
 
-        ref_columns, ref_data = self._get_common_cols_data(self._port)
-        self.assertEqual(ref_columns, columns)
-        self.assertEqual(ref_data, data)
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
 
     def test_create_invalid_json_binding_profile(self):
         arglist = [
@@ -239,9 +261,8 @@ class TestCreatePort(TestPort):
             'name': 'test-port',
         })
 
-        ref_columns, ref_data = self._get_common_cols_data(self._port)
-        self.assertEqual(ref_columns, columns)
-        self.assertEqual(ref_data, data)
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
 
     def test_create_with_security_group(self):
         secgroup = network_fakes.FakeSecurityGroup.create_one_security_group()
@@ -269,9 +290,8 @@ class TestCreatePort(TestPort):
             'name': 'test-port',
         })
 
-        ref_columns, ref_data = self._get_common_cols_data(self._port)
-        self.assertEqual(ref_columns, columns)
-        self.assertEqual(ref_data, data)
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
 
     def test_create_port_with_dns_name(self):
         arglist = [
@@ -296,9 +316,8 @@ class TestCreatePort(TestPort):
             'name': 'test-port',
         })
 
-        ref_columns, ref_data = self._get_common_cols_data(self._port)
-        self.assertEqual(ref_columns, columns)
-        self.assertEqual(ref_data, data)
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
 
     def test_create_with_security_groups(self):
         sg_1 = network_fakes.FakeSecurityGroup.create_one_security_group()
@@ -327,9 +346,8 @@ class TestCreatePort(TestPort):
             'name': 'test-port',
         })
 
-        ref_columns, ref_data = self._get_common_cols_data(self._port)
-        self.assertEqual(ref_columns, columns)
-        self.assertEqual(ref_data, data)
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
 
     def test_create_with_no_security_groups(self):
         arglist = [
@@ -354,9 +372,8 @@ class TestCreatePort(TestPort):
             'name': 'test-port',
         })
 
-        ref_columns, ref_data = self._get_common_cols_data(self._port)
-        self.assertEqual(ref_columns, columns)
-        self.assertEqual(ref_data, data)
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
 
     def test_create_port_with_allowed_address_pair_ipaddr(self):
         pairs = [{'ip_address': '192.168.1.123'},
@@ -385,9 +402,8 @@ class TestCreatePort(TestPort):
             'name': 'test-port',
         })
 
-        ref_columns, ref_data = self._get_common_cols_data(self._port)
-        self.assertEqual(ref_columns, columns)
-        self.assertEqual(ref_data, data)
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
 
     def test_create_port_with_allowed_address_pair(self):
         pairs = [{'ip_address': '192.168.1.123',
@@ -422,9 +438,8 @@ class TestCreatePort(TestPort):
             'name': 'test-port',
         })
 
-        ref_columns, ref_data = self._get_common_cols_data(self._port)
-        self.assertEqual(ref_columns, columns)
-        self.assertEqual(ref_data, data)
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
 
     def test_create_port_with_qos(self):
         qos_policy = network_fakes.FakeNetworkQosPolicy.create_one_qos_policy()
@@ -451,9 +466,8 @@ class TestCreatePort(TestPort):
             'name': 'test-port',
         })
 
-        ref_columns, ref_data = self._get_common_cols_data(self._port)
-        self.assertEqual(ref_columns, columns)
-        self.assertEqual(ref_data, data)
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
 
     def test_create_port_security_enabled(self):
         arglist = [
@@ -583,7 +597,7 @@ class TestDeletePort(TestPort):
         )
 
 
-class TestListPort(TestPort):
+class TestListPort(TestPort, _test_tag.TestListTagMixin):
 
     _ports = network_fakes.FakePort.create_ports(count=3)
 
@@ -603,6 +617,7 @@ class TestListPort(TestPort):
         'Status',
         'Security Groups',
         'Device Owner',
+        'Tags',
     )
 
     data = []
@@ -625,6 +640,7 @@ class TestListPort(TestPort):
             prt.status,
             utils.format_list(prt.security_group_ids),
             prt.device_owner,
+            utils.format_list(prt.tags),
         ))
 
     def setUp(self):
@@ -642,6 +658,8 @@ class TestListPort(TestPort):
         self.network.find_router = mock.Mock(return_value=fake_router)
         self.network.find_network = mock.Mock(return_value=fake_network)
         self.app.client_manager.compute = mock.Mock()
+        # TestUnsetTagMixin
+        self._tag_list_resource_mock = self.network.ports
 
     def test_port_list_no_options(self):
         arglist = []
@@ -902,9 +920,9 @@ class TestListPort(TestPort):
         self.assertEqual(self.data, list(data))
 
 
-class TestSetPort(TestPort):
+class TestSetPort(TestPort, _test_tag.TestSetTagMixin):
 
-    _port = network_fakes.FakePort.create_one_port()
+    _port = network_fakes.FakePort.create_one_port({'tags': ['green', 'red']})
 
     def setUp(self):
         super(TestSetPort, self).setUp()
@@ -912,9 +930,14 @@ class TestSetPort(TestPort):
         self.network.find_subnet = mock.Mock(return_value=self.fake_subnet)
         self.network.find_port = mock.Mock(return_value=self._port)
         self.network.update_port = mock.Mock(return_value=None)
+        self.network.set_tags = mock.Mock(return_value=None)
 
         # Get the command object to test
         self.cmd = port.SetPort(self.app, self.namespace)
+        # TestSetTagMixin
+        self._tag_resource_name = 'port'
+        self._tag_test_resource = self._port
+        self._tag_update_resource_mock = self.network.update_port
 
     def test_set_port_defaults(self):
         arglist = [
@@ -926,8 +949,8 @@ class TestSetPort(TestPort):
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
 
         result = self.cmd.take_action(parsed_args)
-        attrs = {}
-        self.network.update_port.assert_called_once_with(self._port, **attrs)
+        self.assertFalse(self.network.update_port.called)
+        self.assertFalse(self.network.set_tags.called)
         self.assertIsNone(result)
 
     def test_set_port_fixed_ip(self):
@@ -1412,6 +1435,7 @@ class TestShowPort(TestPort):
 
     # The port to show.
     _port = network_fakes.FakePort.create_one_port()
+    columns, data = TestPort._get_common_cols_data(_port)
 
     def setUp(self):
         super(TestShowPort, self).setUp()
@@ -1442,12 +1466,11 @@ class TestShowPort(TestPort):
         self.network.find_port.assert_called_once_with(
             self._port.name, ignore_missing=False)
 
-        ref_columns, ref_data = self._get_common_cols_data(self._port)
-        self.assertEqual(ref_columns, columns)
-        self.assertEqual(ref_data, data)
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
 
 
-class TestUnsetPort(TestPort):
+class TestUnsetPort(TestPort, _test_tag.TestUnsetTagMixin):
 
     def setUp(self):
         super(TestUnsetPort, self).setUp()
@@ -1456,14 +1479,20 @@ class TestUnsetPort(TestPort):
                             'ip_address': '0.0.0.1'},
                            {'subnet_id': '042eb10a-3a18-4658-ab-cf47c8d03152',
                             'ip_address': '1.0.0.0'}],
-             'binding:profile': {'batman': 'Joker', 'Superman': 'LexLuthor'}})
+             'binding:profile': {'batman': 'Joker', 'Superman': 'LexLuthor'},
+             'tags': ['green', 'red'], })
         self.fake_subnet = network_fakes.FakeSubnet.create_one_subnet(
             {'id': '042eb10a-3a18-4658-ab-cf47c8d03152'})
         self.network.find_subnet = mock.Mock(return_value=self.fake_subnet)
         self.network.find_port = mock.Mock(return_value=self._testport)
         self.network.update_port = mock.Mock(return_value=None)
+        self.network.set_tags = mock.Mock(return_value=None)
         # Get the command object to test
         self.cmd = port.UnsetPort(self.app, self.namespace)
+        # TestUnsetTagMixin
+        self._tag_resource_name = 'port'
+        self._tag_test_resource = self._testport
+        self._tag_update_resource_mock = self.network.update_port
 
     def test_unset_port_parameters(self):
         arglist = [
diff --git a/openstackclient/tests/unit/network/v2/test_router.py b/openstackclient/tests/unit/network/v2/test_router.py
index c153fe4a..d65c9aa9 100644
--- a/openstackclient/tests/unit/network/v2/test_router.py
+++ b/openstackclient/tests/unit/network/v2/test_router.py
@@ -19,6 +19,7 @@ from osc_lib import utils as osc_utils
 
 from openstackclient.network.v2 import router
 from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes_v3
+from openstackclient.tests.unit.network.v2 import _test_tag
 from openstackclient.tests.unit.network.v2 import fakes as network_fakes
 from openstackclient.tests.unit import utils as tests_utils
 
@@ -111,7 +112,7 @@ class TestAddSubnetToRouter(TestRouter):
         self.assertIsNone(result)
 
 
-class TestCreateRouter(TestRouter):
+class TestCreateRouter(TestRouter, _test_tag.TestCreateTagMixin):
 
     # The new router created.
     new_router = network_fakes.FakeRouter.create_one_router()
@@ -129,6 +130,7 @@ class TestCreateRouter(TestRouter):
         'project_id',
         'routes',
         'status',
+        'tags',
     )
     data = (
         router._format_admin_state(new_router.admin_state_up),
@@ -143,22 +145,42 @@ class TestCreateRouter(TestRouter):
         new_router.tenant_id,
         router._format_routes(new_router.routes),
         new_router.status,
+        osc_utils.format_list(new_router.tags),
     )
 
     def setUp(self):
         super(TestCreateRouter, self).setUp()
 
         self.network.create_router = mock.Mock(return_value=self.new_router)
+        self.network.set_tags = mock.Mock(return_value=None)
 
         # Get the command object to test
         self.cmd = router.CreateRouter(self.app, self.namespace)
 
+        # TestCreateTagMixin
+        self._tag_test_resource = self.new_router
+        self._tag_create_resource_mock = self.network.create_router
+        self._tag_create_required_arglist = [
+            self.new_router.name,
+        ]
+        self._tag_create_required_verifylist = [
+            ('name', self.new_router.name),
+            ('enable', True),
+            ('distributed', False),
+            ('ha', False),
+        ]
+        self._tag_create_required_attrs = {
+            'admin_state_up': True,
+            'name': self.new_router.name,
+        }
+
     def test_create_no_options(self):
         arglist = []
         verifylist = []
 
         self.assertRaises(tests_utils.ParserException, self.check_parser,
                           self.cmd, arglist, verifylist)
+        self.assertFalse(self.network.set_tags.called)
 
     def test_create_default_options(self):
         arglist = [
@@ -178,6 +200,7 @@ class TestCreateRouter(TestRouter):
             'admin_state_up': True,
             'name': self.new_router.name,
         })
+        self.assertFalse(self.network.set_tags.called)
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, data)
 
@@ -345,7 +368,7 @@ class TestDeleteRouter(TestRouter):
         )
 
 
-class TestListRouter(TestRouter):
+class TestListRouter(TestRouter, _test_tag.TestListTagMixin):
 
     # The routers going to be listed up.
     routers = network_fakes.FakeRouter.create_routers(count=3)
@@ -363,11 +386,13 @@ class TestListRouter(TestRouter):
     columns_long = columns + (
         'Routes',
         'External gateway info',
-        'Availability zones'
+        'Availability zones',
+        'Tags',
     )
     columns_long_no_az = columns + (
         'Routes',
         'External gateway info',
+        'Tags',
     )
 
     data = []
@@ -404,6 +429,7 @@ class TestListRouter(TestRouter):
                 router._format_routes(r.routes),
                 router._format_external_gateway_info(r.external_gateway_info),
                 osc_utils.format_list(r.availability_zones),
+                osc_utils.format_list(r.tags),
             )
         )
     data_long_no_az = []
@@ -413,6 +439,7 @@ class TestListRouter(TestRouter):
             data[i] + (
                 router._format_routes(r.routes),
                 router._format_external_gateway_info(r.external_gateway_info),
+                osc_utils.format_list(r.tags),
             )
         )
 
@@ -432,6 +459,9 @@ class TestListRouter(TestRouter):
         self.network.get_agent = mock.Mock(return_value=self._testagent)
         self.network.get_router = mock.Mock(return_value=self.routers[0])
 
+        # TestListTagMixin
+        self._tag_list_resource_mock = self.network.routers
+
     def test_router_list_no_options(self):
         arglist = []
         verifylist = [
@@ -684,26 +714,33 @@ class TestRemoveSubnetFromRouter(TestRouter):
         self.assertIsNone(result)
 
 
-class TestSetRouter(TestRouter):
+class TestSetRouter(TestRouter, _test_tag.TestSetTagMixin):
 
     # The router to set.
     _default_route = {'destination': '10.20.20.0/24', 'nexthop': '10.20.30.1'}
     _network = network_fakes.FakeNetwork.create_one_network()
     _subnet = network_fakes.FakeSubnet.create_one_subnet()
     _router = network_fakes.FakeRouter.create_one_router(
-        attrs={'routes': [_default_route]}
+        attrs={'routes': [_default_route],
+               'tags': ['green', 'red']}
     )
 
     def setUp(self):
         super(TestSetRouter, self).setUp()
         self.network.router_add_gateway = mock.Mock()
         self.network.update_router = mock.Mock(return_value=None)
+        self.network.set_tags = mock.Mock(return_value=None)
         self.network.find_router = mock.Mock(return_value=self._router)
         self.network.find_network = mock.Mock(return_value=self._network)
         self.network.find_subnet = mock.Mock(return_value=self._subnet)
         # Get the command object to test
         self.cmd = router.SetRouter(self.app, self.namespace)
 
+        # TestSetTagMixin
+        self._tag_resource_name = 'router'
+        self._tag_test_resource = self._router
+        self._tag_update_resource_mock = self.network.update_router
+
     def test_set_this(self):
         arglist = [
             self._router.name,
@@ -902,9 +939,8 @@ class TestSetRouter(TestRouter):
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
         result = self.cmd.take_action(parsed_args)
 
-        attrs = {}
-        self.network.update_router.assert_called_once_with(
-            self._router, **attrs)
+        self.assertFalse(self.network.update_router.called)
+        self.assertFalse(self.network.set_tags.called)
         self.assertIsNone(result)
 
     def test_wrong_gateway_params(self):
@@ -1030,6 +1066,7 @@ class TestShowRouter(TestRouter):
         'project_id',
         'routes',
         'status',
+        'tags',
     )
     data = (
         router._format_admin_state(_router.admin_state_up),
@@ -1044,6 +1081,7 @@ class TestShowRouter(TestRouter):
         _router.tenant_id,
         router._format_routes(_router.routes),
         _router.status,
+        osc_utils.format_list(_router.tags),
     )
 
     def setUp(self):
@@ -1086,12 +1124,18 @@ class TestUnsetRouter(TestRouter):
             {'routes': [{"destination": "192.168.101.1/24",
                          "nexthop": "172.24.4.3"},
                         {"destination": "192.168.101.2/24",
-                         "nexthop": "172.24.4.3"}], })
+                         "nexthop": "172.24.4.3"}],
+             'tags': ['green', 'red'], })
         self.fake_subnet = network_fakes.FakeSubnet.create_one_subnet()
         self.network.find_router = mock.Mock(return_value=self._testrouter)
         self.network.update_router = mock.Mock(return_value=None)
+        self.network.set_tags = mock.Mock(return_value=None)
         # Get the command object to test
         self.cmd = router.UnsetRouter(self.app, self.namespace)
+        # TestUnsetTagMixin
+        self._tag_resource_name = 'router'
+        self._tag_test_resource = self._testrouter
+        self._tag_update_resource_mock = self.network.update_router
 
     def test_unset_router_params(self):
         arglist = [
diff --git a/openstackclient/tests/unit/network/v2/test_subnet.py b/openstackclient/tests/unit/network/v2/test_subnet.py
index 47de5616..509fbe6b 100644
--- a/openstackclient/tests/unit/network/v2/test_subnet.py
+++ b/openstackclient/tests/unit/network/v2/test_subnet.py
@@ -19,6 +19,7 @@ from osc_lib import utils
 
 from openstackclient.network.v2 import subnet as subnet_v2
 from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes_v3
+from openstackclient.tests.unit.network.v2 import _test_tag
 from openstackclient.tests.unit.network.v2 import fakes as network_fakes
 from openstackclient.tests.unit import utils as tests_utils
 
@@ -36,7 +37,7 @@ class TestSubnet(network_fakes.TestNetworkV2):
         self.domains_mock = self.app.client_manager.identity.domains
 
 
-class TestCreateSubnet(TestSubnet):
+class TestCreateSubnet(TestSubnet, _test_tag.TestCreateTagMixin):
 
     project = identity_fakes_v3.FakeProject.create_one_project()
     domain = identity_fakes_v3.FakeDomain.create_one_domain()
@@ -125,6 +126,7 @@ class TestCreateSubnet(TestSubnet):
         'segment_id',
         'service_types',
         'subnetpool_id',
+        'tags',
     )
 
     data = (
@@ -145,6 +147,7 @@ class TestCreateSubnet(TestSubnet):
         _subnet.segment_id,
         utils.format_list(_subnet.service_types),
         _subnet.subnetpool_id,
+        utils.format_list(_subnet.tags),
     )
 
     data_subnet_pool = (
@@ -165,6 +168,7 @@ class TestCreateSubnet(TestSubnet):
         _subnet_from_pool.segment_id,
         utils.format_list(_subnet_from_pool.service_types),
         _subnet_from_pool.subnetpool_id,
+        utils.format_list(_subnet.tags),
     )
 
     data_ipv6 = (
@@ -185,6 +189,7 @@ class TestCreateSubnet(TestSubnet):
         _subnet_ipv6.segment_id,
         utils.format_list(_subnet_ipv6.service_types),
         _subnet_ipv6.subnetpool_id,
+        utils.format_list(_subnet.tags),
     )
 
     def setUp(self):
@@ -197,6 +202,8 @@ class TestCreateSubnet(TestSubnet):
         self.domains_mock.get.return_value = self.domain
 
         # Mock SDK calls for all tests.
+        self.network.create_subnet = mock.Mock(return_value=self._subnet)
+        self.network.set_tags = mock.Mock(return_value=None)
         self.network.find_network = mock.Mock(return_value=self._network)
         self.network.find_segment = mock.Mock(
             return_value=self._network_segment
@@ -205,6 +212,28 @@ class TestCreateSubnet(TestSubnet):
             return_value=self._subnet_pool
         )
 
+        # TestUnsetTagMixin
+        self._tag_test_resource = self._subnet
+        self._tag_create_resource_mock = self.network.create_subnet
+        self._tag_create_required_arglist = [
+            "--subnet-range", self._subnet.cidr,
+            "--network", self._subnet.network_id,
+            self._subnet.name,
+        ]
+        self._tag_create_required_verifylist = [
+            ('name', self._subnet.name),
+            ('subnet_range', self._subnet.cidr),
+            ('network', self._subnet.network_id),
+            ('ip_version', self._subnet.ip_version),
+            ('gateway', 'auto'),
+        ]
+        self._tag_create_required_attrs = {
+            'cidr': self._subnet.cidr,
+            'ip_version': self._subnet.ip_version,
+            'name': self._subnet.name,
+            'network_id': self._subnet.network_id,
+        }
+
     def test_create_no_options(self):
         arglist = []
         verifylist = []
@@ -213,10 +242,11 @@ class TestCreateSubnet(TestSubnet):
         # throw a "ParserExecption"
         self.assertRaises(tests_utils.ParserException,
                           self.check_parser, self.cmd, arglist, verifylist)
+        self.assertFalse(self.network.create_subnet.called)
+        self.assertFalse(self.network.set_tags.called)
 
     def test_create_default_options(self):
         # Mock SDK calls for this test.
-        self.network.create_subnet = mock.Mock(return_value=self._subnet)
         self._network.id = self._subnet.network_id
 
         arglist = [
@@ -230,7 +260,6 @@ class TestCreateSubnet(TestSubnet):
             ('network', self._subnet.network_id),
             ('ip_version', self._subnet.ip_version),
             ('gateway', 'auto'),
-
         ]
 
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
@@ -242,13 +271,14 @@ class TestCreateSubnet(TestSubnet):
             'name': self._subnet.name,
             'network_id': self._subnet.network_id,
         })
+        self.assertFalse(self.network.set_tags.called)
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, data)
 
     def test_create_from_subnet_pool_options(self):
         # Mock SDK calls for this test.
-        self.network.create_subnet = \
-            mock.Mock(return_value=self._subnet_from_pool)
+        self.network.create_subnet.return_value = self._subnet_from_pool
+        self.network.set_tags = mock.Mock(return_value=None)
         self._network.id = self._subnet_from_pool.network_id
 
         arglist = [
@@ -309,7 +339,7 @@ class TestCreateSubnet(TestSubnet):
 
     def test_create_options_subnet_range_ipv6(self):
         # Mock SDK calls for this test.
-        self.network.create_subnet = mock.Mock(return_value=self._subnet_ipv6)
+        self.network.create_subnet.return_value = self._subnet_ipv6
         self._network.id = self._subnet_ipv6.network_id
 
         arglist = [
@@ -376,12 +406,12 @@ class TestCreateSubnet(TestSubnet):
             'allocation_pools': self._subnet_ipv6.allocation_pools,
             'service_types': self._subnet_ipv6.service_types,
         })
+        self.assertFalse(self.network.set_tags.called)
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data_ipv6, data)
 
     def test_create_with_network_segment(self):
         # Mock SDK calls for this test.
-        self.network.create_subnet = mock.Mock(return_value=self._subnet)
         self._network.id = self._subnet.network_id
 
         arglist = [
@@ -410,12 +440,12 @@ class TestCreateSubnet(TestSubnet):
             'network_id': self._subnet.network_id,
             'segment_id': self._network_segment.id,
         })
+        self.assertFalse(self.network.set_tags.called)
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, data)
 
     def test_create_with_description(self):
         # Mock SDK calls for this test.
-        self.network.create_subnet = mock.Mock(return_value=self._subnet)
         self._network.id = self._subnet.network_id
 
         arglist = [
@@ -444,6 +474,7 @@ class TestCreateSubnet(TestSubnet):
             'network_id': self._subnet.network_id,
             'description': self._subnet.description,
         })
+        self.assertFalse(self.network.set_tags.called)
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, data)
 
@@ -527,7 +558,7 @@ class TestDeleteSubnet(TestSubnet):
         )
 
 
-class TestListSubnet(TestSubnet):
+class TestListSubnet(TestSubnet, _test_tag.TestListTagMixin):
     # The subnets going to be listed up.
     _subnet = network_fakes.FakeSubnet.create_subnets(count=3)
 
@@ -546,6 +577,7 @@ class TestListSubnet(TestSubnet):
         'IP Version',
         'Gateway',
         'Service Types',
+        'Tags',
     )
 
     data = []
@@ -572,6 +604,7 @@ class TestListSubnet(TestSubnet):
             subnet.ip_version,
             subnet.gateway_ip,
             utils.format_list(subnet.service_types),
+            utils.format_list(subnet.tags),
         ))
 
     def setUp(self):
@@ -582,6 +615,9 @@ class TestListSubnet(TestSubnet):
 
         self.network.subnets = mock.Mock(return_value=self._subnet)
 
+        # TestUnsetTagMixin
+        self._tag_list_resource_mock = self.network.subnets
+
     def test_subnet_list_no_options(self):
         arglist = []
         verifylist = [
@@ -802,15 +838,21 @@ class TestListSubnet(TestSubnet):
         self.assertEqual(self.data, list(data))
 
 
-class TestSetSubnet(TestSubnet):
+class TestSetSubnet(TestSubnet, _test_tag.TestSetTagMixin):
 
-    _subnet = network_fakes.FakeSubnet.create_one_subnet()
+    _subnet = network_fakes.FakeSubnet.create_one_subnet(
+        {'tags': ['green', 'red']})
 
     def setUp(self):
         super(TestSetSubnet, self).setUp()
         self.network.update_subnet = mock.Mock(return_value=None)
+        self.network.set_tags = mock.Mock(return_value=None)
         self.network.find_subnet = mock.Mock(return_value=self._subnet)
         self.cmd = subnet_v2.SetSubnet(self.app, self.namespace)
+        # TestSetTagMixin
+        self._tag_resource_name = 'subnet'
+        self._tag_test_resource = self._subnet
+        self._tag_update_resource_mock = self.network.update_subnet
 
     def test_set_this(self):
         arglist = [
@@ -867,8 +909,8 @@ class TestSetSubnet(TestSubnet):
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
         result = self.cmd.take_action(parsed_args)
 
-        attrs = {}
-        self.network.update_subnet.assert_called_with(self._subnet, **attrs)
+        self.assertFalse(self.network.update_subnet.called)
+        self.assertFalse(self.network.set_tags.called)
         self.assertIsNone(result)
 
     def test_append_options(self):
@@ -982,6 +1024,7 @@ class TestShowSubnet(TestSubnet):
         'segment_id',
         'service_types',
         'subnetpool_id',
+        'tags',
     )
 
     data = (
@@ -1002,6 +1045,7 @@ class TestShowSubnet(TestSubnet):
         _subnet.segment_id,
         utils.format_list(_subnet.service_types),
         _subnet.subnetpool_id,
+        utils.format_list(_subnet.tags),
     )
 
     def setUp(self):
@@ -1039,7 +1083,7 @@ class TestShowSubnet(TestSubnet):
         self.assertEqual(self.data, data)
 
 
-class TestUnsetSubnet(TestSubnet):
+class TestUnsetSubnet(TestSubnet, _test_tag.TestUnsetTagMixin):
 
     def setUp(self):
         super(TestUnsetSubnet, self).setUp()
@@ -1055,11 +1099,17 @@ class TestUnsetSubnet(TestSubnet):
                                   {'start': '8.8.8.160',
                                    'end': '8.8.8.170'}],
              'service_types': ['network:router_gateway',
-                               'network:floatingip_agent_gateway'], })
+                               'network:floatingip_agent_gateway'],
+             'tags': ['green', 'red'], })
         self.network.find_subnet = mock.Mock(return_value=self._testsubnet)
         self.network.update_subnet = mock.Mock(return_value=None)
+        self.network.set_tags = mock.Mock(return_value=None)
         # Get the command object to test
         self.cmd = subnet_v2.UnsetSubnet(self.app, self.namespace)
+        # TestUnsetTagMixin
+        self._tag_resource_name = 'subnet'
+        self._tag_test_resource = self._testsubnet
+        self._tag_update_resource_mock = self.network.update_subnet
 
     def test_unset_subnet_params(self):
         arglist = [
diff --git a/openstackclient/tests/unit/network/v2/test_subnet_pool.py b/openstackclient/tests/unit/network/v2/test_subnet_pool.py
index 80a57bbb..af493856 100644
--- a/openstackclient/tests/unit/network/v2/test_subnet_pool.py
+++ b/openstackclient/tests/unit/network/v2/test_subnet_pool.py
@@ -20,6 +20,7 @@ from osc_lib import utils
 
 from openstackclient.network.v2 import subnet_pool
 from openstackclient.tests.unit.identity.v3 import fakes as identity_fakes_v3
+from openstackclient.tests.unit.network.v2 import _test_tag
 from openstackclient.tests.unit.network.v2 import fakes as network_fakes
 from openstackclient.tests.unit import utils as tests_utils
 
@@ -37,7 +38,7 @@ class TestSubnetPool(network_fakes.TestNetworkV2):
         self.domains_mock = self.app.client_manager.identity.domains
 
 
-class TestCreateSubnetPool(TestSubnetPool):
+class TestCreateSubnetPool(TestSubnetPool, _test_tag.TestCreateTagMixin):
 
     project = identity_fakes_v3.FakeProject.create_one_project()
     domain = identity_fakes_v3.FakeDomain.create_one_domain()
@@ -60,6 +61,7 @@ class TestCreateSubnetPool(TestSubnetPool):
         'prefixes',
         'project_id',
         'shared',
+        'tags',
     )
     data = (
         _subnet_pool.address_scope_id,
@@ -75,6 +77,7 @@ class TestCreateSubnetPool(TestSubnetPool):
         utils.format_list(_subnet_pool.prefixes),
         _subnet_pool.project_id,
         _subnet_pool.shared,
+        utils.format_list(_subnet_pool.tags),
     )
 
     def setUp(self):
@@ -82,6 +85,7 @@ class TestCreateSubnetPool(TestSubnetPool):
 
         self.network.create_subnet_pool = mock.Mock(
             return_value=self._subnet_pool)
+        self.network.set_tags = mock.Mock(return_value=None)
 
         # Get the command object to test
         self.cmd = subnet_pool.CreateSubnetPool(self.app, self.namespace)
@@ -92,12 +96,29 @@ class TestCreateSubnetPool(TestSubnetPool):
         self.projects_mock.get.return_value = self.project
         self.domains_mock.get.return_value = self.domain
 
+        # TestUnsetTagMixin
+        self._tag_test_resource = self._subnet_pool
+        self._tag_create_resource_mock = self.network.create_subnet_pool
+        self._tag_create_required_arglist = [
+            '--pool-prefix', '10.0.10.0/24',
+            self._subnet_pool.name,
+        ]
+        self._tag_create_required_verifylist = [
+            ('prefixes', ['10.0.10.0/24']),
+            ('name', self._subnet_pool.name),
+        ]
+        self._tag_create_required_attrs = {
+            'prefixes': ['10.0.10.0/24'],
+            'name': self._subnet_pool.name,
+        }
+
     def test_create_no_options(self):
         arglist = []
         verifylist = []
 
         self.assertRaises(tests_utils.ParserException, self.check_parser,
                           self.cmd, arglist, verifylist)
+        self.assertFalse(self.network.set_tags.called)
 
     def test_create_no_pool_prefix(self):
         """Make sure --pool-prefix is a required argument"""
@@ -127,6 +148,7 @@ class TestCreateSubnetPool(TestSubnetPool):
             'prefixes': ['10.0.10.0/24'],
             'name': self._subnet_pool.name,
         })
+        self.assertFalse(self.network.set_tags.called)
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, data)
 
@@ -374,7 +396,7 @@ class TestDeleteSubnetPool(TestSubnetPool):
         )
 
 
-class TestListSubnetPool(TestSubnetPool):
+class TestListSubnetPool(TestSubnetPool, _test_tag.TestListTagMixin):
     # The subnet pools going to be listed up.
     _subnet_pools = network_fakes.FakeSubnetPool.create_subnet_pools(count=3)
 
@@ -388,6 +410,7 @@ class TestListSubnetPool(TestSubnetPool):
         'Address Scope',
         'Default Subnet Pool',
         'Shared',
+        'Tags',
     )
 
     data = []
@@ -408,6 +431,7 @@ class TestListSubnetPool(TestSubnetPool):
             pool.address_scope_id,
             pool.is_default,
             pool.shared,
+            utils.format_list(pool.tags),
         ))
 
     def setUp(self):
@@ -418,6 +442,9 @@ class TestListSubnetPool(TestSubnetPool):
 
         self.network.subnet_pools = mock.Mock(return_value=self._subnet_pools)
 
+        # TestUnsetTagMixin
+        self._tag_list_resource_mock = self.network.subnet_pools
+
     def test_subnet_pool_list_no_option(self):
         arglist = []
         verifylist = [
@@ -585,11 +612,12 @@ class TestListSubnetPool(TestSubnetPool):
         self.assertEqual(self.data, list(data))
 
 
-class TestSetSubnetPool(TestSubnetPool):
+class TestSetSubnetPool(TestSubnetPool, _test_tag.TestSetTagMixin):
 
     # The subnet_pool to set.
     _subnet_pool = network_fakes.FakeSubnetPool.create_one_subnet_pool(
-        {'default_quota': 10},
+        {'default_quota': 10,
+         'tags': ['green', 'red']}
     )
 
     _address_scope = network_fakes.FakeAddressScope.create_one_address_scope()
@@ -598,6 +626,7 @@ class TestSetSubnetPool(TestSubnetPool):
         super(TestSetSubnetPool, self).setUp()
 
         self.network.update_subnet_pool = mock.Mock(return_value=None)
+        self.network.set_tags = mock.Mock(return_value=None)
 
         self.network.find_subnet_pool = mock.Mock(
             return_value=self._subnet_pool)
@@ -608,6 +637,11 @@ class TestSetSubnetPool(TestSubnetPool):
         # Get the command object to test
         self.cmd = subnet_pool.SetSubnetPool(self.app, self.namespace)
 
+        # TestUnsetTagMixin
+        self._tag_resource_name = 'subnet_pool'
+        self._tag_test_resource = self._subnet_pool
+        self._tag_update_resource_mock = self.network.update_subnet_pool
+
     def test_set_this(self):
         arglist = [
             '--name', 'noob',
@@ -667,9 +701,8 @@ class TestSetSubnetPool(TestSubnetPool):
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
         result = self.cmd.take_action(parsed_args)
 
-        attrs = {}
-        self.network.update_subnet_pool.assert_called_once_with(
-            self._subnet_pool, **attrs)
+        self.assertFalse(self.network.update_subnet_pool.called)
+        self.assertFalse(self.network.set_tags.called)
         self.assertIsNone(result)
 
     def test_set_len_negative(self):
@@ -854,6 +887,7 @@ class TestShowSubnetPool(TestSubnetPool):
         'prefixes',
         'project_id',
         'shared',
+        'tags',
     )
 
     data = (
@@ -870,6 +904,7 @@ class TestShowSubnetPool(TestSubnetPool):
         utils.format_list(_subnet_pool.prefixes),
         _subnet_pool.tenant_id,
         _subnet_pool.shared,
+        utils.format_list(_subnet_pool.tags),
     )
 
     def setUp(self):
@@ -908,26 +943,36 @@ class TestShowSubnetPool(TestSubnetPool):
         self.assertEqual(self.data, data)
 
 
-class TestUnsetSubnetPool(TestSubnetPool):
+class TestUnsetSubnetPool(TestSubnetPool, _test_tag.TestUnsetTagMixin):
 
     def setUp(self):
         super(TestUnsetSubnetPool, self).setUp()
         self._subnetpool = network_fakes.FakeSubnetPool.create_one_subnet_pool(
             {'prefixes': ['10.0.10.0/24', '10.1.10.0/24',
-                          '10.2.10.0/24'], })
+                          '10.2.10.0/24'],
+             'tags': ['green', 'red']})
         self.network.find_subnet_pool = mock.Mock(
             return_value=self._subnetpool)
         self.network.update_subnet_pool = mock.Mock(return_value=None)
+        self.network.set_tags = mock.Mock(return_value=None)
         # Get the command object to test
         self.cmd = subnet_pool.UnsetSubnetPool(self.app, self.namespace)
 
+        # TestUnsetTagMixin
+        self._tag_resource_name = 'subnet_pool'
+        self._tag_test_resource = self._subnetpool
+        self._tag_update_resource_mock = self.network.update_subnet_pool
+
     def test_unset_subnet_pool(self):
         arglist = [
             '--pool-prefix', '10.0.10.0/24',
             '--pool-prefix', '10.1.10.0/24',
             self._subnetpool.name,
         ]
-        verifylist = [('prefixes', ['10.0.10.0/24', '10.1.10.0/24'])]
+        verifylist = [
+            ('prefixes', ['10.0.10.0/24', '10.1.10.0/24']),
+            ('subnet_pool', self._subnetpool.name),
+        ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
         result = self.cmd.take_action(parsed_args)
         attrs = {'prefixes': ['10.2.10.0/24']}
@@ -940,7 +985,10 @@ class TestUnsetSubnetPool(TestSubnetPool):
             '--pool-prefix', '10.100.1.1/25',
             self._subnetpool.name,
         ]
-        verifylist = [('prefixes', ['10.100.1.1/25'])]
+        verifylist = [
+            ('prefixes', ['10.100.1.1/25']),
+            ('subnet_pool', self._subnetpool.name),
+        ]
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
         self.assertRaises(exceptions.CommandError,
                           self.cmd.take_action,
diff --git a/openstackclient/tests/unit/utils.py b/openstackclient/tests/unit/utils.py
index 3c5c8683..8f9cc7b1 100644
--- a/openstackclient/tests/unit/utils.py
+++ b/openstackclient/tests/unit/utils.py
@@ -25,6 +25,12 @@ class ParserException(Exception):
     pass
 
 
+class CompareBySet(list):
+    """Class to compare value using set."""
+    def __eq__(self, other):
+        return set(self) == set(other)
+
+
 class TestCase(testtools.TestCase):
 
     def setUp(self):