network tag UT: avoid using mix-in test class

This is a follow-up patch on https://review.openstack.org/#/c/461195/
There is a suggestion to keep test code more straight-forward
and avoid using mix-in to reduce the code complexity.
This commit moves all logic implemented in _test_tag.py
into individual network tests.

Change-Id: I0a9f8c6cd758db9035b0fd60ce4b9bfc791b6cbd

6 files changed, 628 insertions, 359 deletions

diff --git a/openstackclient/tests/unit/network/v2/_test_tag.py b/openstackclient/tests/unit/network/v2/_test_tag.py
deleted file mode 100644
index bd461537..00000000
--- a/openstackclient/tests/unit/network/v2/_test_tag.py
+++ /dev/null
@@ -1,190 +0,0 @@
-#   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/test_network.py b/openstackclient/tests/unit/network/v2/test_network.py
index e620cd9c..7b20c793 100644
--- a/openstackclient/tests/unit/network/v2/test_network.py
+++ b/openstackclient/tests/unit/network/v2/test_network.py
@@ -22,7 +22,6 @@ 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
 
@@ -42,7 +41,7 @@ class TestNetwork(network_fakes.TestNetworkV2):
         self.domains_mock = self.app.client_manager.identity.domains
 
 
-class TestCreateNetworkIdentityV3(TestNetwork, _test_tag.TestCreateTagMixin):
+class TestCreateNetworkIdentityV3(TestNetwork):
 
     project = identity_fakes_v3.FakeProject.create_one_project()
     domain = identity_fakes_v3.FakeDomain.create_one_domain()
@@ -115,22 +114,6 @@ class TestCreateNetworkIdentityV3(TestNetwork, _test_tag.TestCreateTagMixin):
         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 = []
@@ -247,6 +230,44 @@ class TestCreateNetworkIdentityV3(TestNetwork, _test_tag.TestCreateTagMixin):
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, data)
 
+    def _test_create_with_tag(self, add_tags=True):
+        arglist = [self._network.name]
+        if add_tags:
+            arglist += ['--tag', 'red', '--tag', 'blue']
+        else:
+            arglist += ['--no-tag']
+        verifylist = [
+            ('name', self._network.name),
+            ('enable', True),
+            ('share', None),
+            ('project', None),
+            ('external', False),
+        ]
+        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.network.create_network.assert_called_once_with(
+            name=self._network.name, admin_state_up=True)
+        if add_tags:
+            self.network.set_tags.assert_called_once_with(
+                self._network,
+                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 TestCreateNetworkIdentityV2(TestNetwork):
 
@@ -461,7 +482,7 @@ class TestDeleteNetwork(TestNetwork):
         self.network.delete_network.assert_has_calls(calls)
 
 
-class TestListNetwork(TestNetwork, _test_tag.TestListTagMixin):
+class TestListNetwork(TestNetwork):
 
     # The networks going to be listed up.
     _network = network_fakes.FakeNetwork.create_networks(count=3)
@@ -820,8 +841,33 @@ class TestListNetwork(TestNetwork, _test_tag.TestListTagMixin):
         self.assertEqual(self.columns, columns)
         self.assertEqual(list(data), list(self.data))
 
+    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.network.networks.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 TestSetNetwork(TestNetwork, _test_tag.TestSetTagMixin):
+
+class TestSetNetwork(TestNetwork):
 
     # The network to set.
     _network = network_fakes.FakeNetwork.create_one_network(
@@ -841,11 +887,6 @@ class TestSetNetwork(TestNetwork, _test_tag.TestSetTagMixin):
         # 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,
@@ -939,6 +980,34 @@ class TestSetNetwork(TestNetwork, _test_tag.TestSetTagMixin):
         self.assertFalse(self.network.set_tags.called)
         self.assertIsNone(result)
 
+    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._network.name)
+        verifylist.append(
+            ('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.network.set_tags.assert_called_once_with(
+            self._network,
+            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 TestShowNetwork(TestNetwork):
 
@@ -1024,7 +1093,7 @@ class TestShowNetwork(TestNetwork):
         self.assertEqual(self.data, data)
 
 
-class TestUnsetNetwork(TestNetwork, _test_tag.TestUnsetTagMixin):
+class TestUnsetNetwork(TestNetwork):
 
     # The network to set.
     _network = network_fakes.FakeNetwork.create_one_network(
@@ -1044,11 +1113,6 @@ class TestUnsetNetwork(TestNetwork, _test_tag.TestUnsetTagMixin):
         # 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), ]
@@ -1059,3 +1123,31 @@ class TestUnsetNetwork(TestNetwork, _test_tag.TestUnsetTagMixin):
         self.assertFalse(self.network.update_network.called)
         self.assertFalse(self.network.set_tags.called)
         self.assertIsNone(result)
+
+    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._network.name)
+        verifylist.append(
+            ('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.network.set_tags.assert_called_once_with(
+            self._network,
+            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/test_port.py b/openstackclient/tests/unit/network/v2/test_port.py
index deda6b41..97be5afd 100644
--- a/openstackclient/tests/unit/network/v2/test_port.py
+++ b/openstackclient/tests/unit/network/v2/test_port.py
@@ -21,7 +21,6 @@ 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
 
@@ -97,7 +96,7 @@ class TestPort(network_fakes.TestNetworkV2):
         return columns, data
 
 
-class TestCreatePort(TestPort, _test_tag.TestCreateTagMixin):
+class TestCreatePort(TestPort):
 
     _port = network_fakes.FakePort.create_one_port()
     columns, data = TestPort._get_common_cols_data(_port)
@@ -116,24 +115,6 @@ class TestCreatePort(TestPort, _test_tag.TestCreateTagMixin):
         # 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,
@@ -517,6 +498,48 @@ class TestCreatePort(TestPort, _test_tag.TestCreateTagMixin):
             'name': 'test-port',
         })
 
+    def _test_create_with_tag(self, add_tags=True):
+        arglist = [
+            '--network', self._port.network_id,
+            'test-port',
+        ]
+        if add_tags:
+            arglist += ['--tag', 'red', '--tag', 'blue']
+        else:
+            arglist += ['--no-tag']
+        verifylist = [
+            ('network', self._port.network_id,),
+            ('enable', True),
+            ('name', 'test-port'),
+        ]
+        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.network.create_port.assert_called_once_with(
+            admin_state_up=True,
+            network_id=self._port.network_id,
+            name='test-port'
+        )
+        if add_tags:
+            self.network.set_tags.assert_called_once_with(
+                self._port,
+                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 TestDeletePort(TestPort):
 
@@ -597,7 +620,7 @@ class TestDeletePort(TestPort):
         )
 
 
-class TestListPort(TestPort, _test_tag.TestListTagMixin):
+class TestListPort(TestPort):
 
     _ports = network_fakes.FakePort.create_ports(count=3)
 
@@ -658,8 +681,6 @@ class TestListPort(TestPort, _test_tag.TestListTagMixin):
         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 = []
@@ -919,8 +940,33 @@ class TestListPort(TestPort, _test_tag.TestListTagMixin):
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, list(data))
 
+    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)
 
-class TestSetPort(TestPort, _test_tag.TestSetTagMixin):
+        self.network.ports.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 TestSetPort(TestPort):
 
     _port = network_fakes.FakePort.create_one_port({'tags': ['green', 'red']})
 
@@ -934,10 +980,6 @@ class TestSetPort(TestPort, _test_tag.TestSetTagMixin):
 
         # 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 = [
@@ -1430,6 +1472,34 @@ class TestSetPort(TestPort, _test_tag.TestSetTagMixin):
                           arglist,
                           None)
 
+    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._port.name)
+        verifylist.append(
+            ('port', self._port.name))
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        self.assertFalse(self.network.update_port.called)
+        self.network.set_tags.assert_called_once_with(
+            self._port,
+            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 TestShowPort(TestPort):
 
@@ -1470,7 +1540,7 @@ class TestShowPort(TestPort):
         self.assertEqual(self.data, data)
 
 
-class TestUnsetPort(TestPort, _test_tag.TestUnsetTagMixin):
+class TestUnsetPort(TestPort):
 
     def setUp(self):
         super(TestUnsetPort, self).setUp()
@@ -1489,10 +1559,6 @@ class TestUnsetPort(TestPort, _test_tag.TestUnsetTagMixin):
         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 = [
@@ -1661,3 +1727,31 @@ class TestUnsetPort(TestPort, _test_tag.TestUnsetTagMixin):
 
         self.network.update_port.assert_called_once_with(_fake_port, **attrs)
         self.assertIsNone(result)
+
+    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._testport.name)
+        verifylist.append(
+            ('port', self._testport.name))
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        self.assertFalse(self.network.update_port.called)
+        self.network.set_tags.assert_called_once_with(
+            self._testport,
+            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/test_router.py b/openstackclient/tests/unit/network/v2/test_router.py
index d65c9aa9..2248db9a 100644
--- a/openstackclient/tests/unit/network/v2/test_router.py
+++ b/openstackclient/tests/unit/network/v2/test_router.py
@@ -19,7 +19,6 @@ 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
 
@@ -112,7 +111,7 @@ class TestAddSubnetToRouter(TestRouter):
         self.assertIsNone(result)
 
 
-class TestCreateRouter(TestRouter, _test_tag.TestCreateTagMixin):
+class TestCreateRouter(TestRouter):
 
     # The new router created.
     new_router = network_fakes.FakeRouter.create_one_router()
@@ -157,23 +156,6 @@ class TestCreateRouter(TestRouter, _test_tag.TestCreateTagMixin):
         # 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 = []
@@ -288,6 +270,45 @@ class TestCreateRouter(TestRouter, _test_tag.TestCreateTagMixin):
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, data)
 
+    def _test_create_with_tag(self, add_tags=True):
+        arglist = [self.new_router.name]
+        if add_tags:
+            arglist += ['--tag', 'red', '--tag', 'blue']
+        else:
+            arglist += ['--no-tag']
+        verifylist = [
+            ('name', self.new_router.name),
+            ('enable', True),
+            ('distributed', False),
+            ('ha', False),
+        ]
+        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.network.create_router.assert_called_once_with(
+            name=self.new_router.name,
+            admin_state_up=True
+        )
+        if add_tags:
+            self.network.set_tags.assert_called_once_with(
+                self.new_router,
+                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 TestDeleteRouter(TestRouter):
 
@@ -368,7 +389,7 @@ class TestDeleteRouter(TestRouter):
         )
 
 
-class TestListRouter(TestRouter, _test_tag.TestListTagMixin):
+class TestListRouter(TestRouter):
 
     # The routers going to be listed up.
     routers = network_fakes.FakeRouter.create_routers(count=3)
@@ -459,9 +480,6 @@ class TestListRouter(TestRouter, _test_tag.TestListTagMixin):
         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 = [
@@ -636,6 +654,31 @@ class TestListRouter(TestRouter, _test_tag.TestListTagMixin):
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, list(data))
 
+    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.network.routers.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 TestRemovePortFromRouter(TestRouter):
     '''Remove port from a Router '''
@@ -714,7 +757,7 @@ class TestRemoveSubnetFromRouter(TestRouter):
         self.assertIsNone(result)
 
 
-class TestSetRouter(TestRouter, _test_tag.TestSetTagMixin):
+class TestSetRouter(TestRouter):
 
     # The router to set.
     _default_route = {'destination': '10.20.20.0/24', 'nexthop': '10.20.30.1'}
@@ -736,11 +779,6 @@ class TestSetRouter(TestRouter, _test_tag.TestSetTagMixin):
         # 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,
@@ -1047,6 +1085,34 @@ class TestSetRouter(TestRouter, _test_tag.TestSetTagMixin):
                 'enable_snat': True, }})
         self.assertIsNone(result)
 
+    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._router.name)
+        verifylist.append(
+            ('router', self._router.name))
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        self.assertFalse(self.network.update_router.called)
+        self.network.set_tags.assert_called_once_with(
+            self._router,
+            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 TestShowRouter(TestRouter):
 
@@ -1132,10 +1198,6 @@ class TestUnsetRouter(TestRouter):
         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 = [
@@ -1184,3 +1246,31 @@ class TestUnsetRouter(TestRouter):
         self.network.update_router.assert_called_once_with(
             self._testrouter, **attrs)
         self.assertIsNone(result)
+
+    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._testrouter.name)
+        verifylist.append(
+            ('router', self._testrouter.name))
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        self.assertFalse(self.network.update_router.called)
+        self.network.set_tags.assert_called_once_with(
+            self._testrouter,
+            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/test_subnet.py b/openstackclient/tests/unit/network/v2/test_subnet.py
index 509fbe6b..c96d680f 100644
--- a/openstackclient/tests/unit/network/v2/test_subnet.py
+++ b/openstackclient/tests/unit/network/v2/test_subnet.py
@@ -19,7 +19,6 @@ 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
 
@@ -37,7 +36,7 @@ class TestSubnet(network_fakes.TestNetworkV2):
         self.domains_mock = self.app.client_manager.identity.domains
 
 
-class TestCreateSubnet(TestSubnet, _test_tag.TestCreateTagMixin):
+class TestCreateSubnet(TestSubnet):
 
     project = identity_fakes_v3.FakeProject.create_one_project()
     domain = identity_fakes_v3.FakeDomain.create_one_domain()
@@ -212,28 +211,6 @@ class TestCreateSubnet(TestSubnet, _test_tag.TestCreateTagMixin):
             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 = []
@@ -478,6 +455,51 @@ class TestCreateSubnet(TestSubnet, _test_tag.TestCreateTagMixin):
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, data)
 
+    def _test_create_with_tag(self, add_tags=True):
+        arglist = [
+            "--subnet-range", self._subnet.cidr,
+            "--network", self._subnet.network_id,
+            self._subnet.name,
+        ]
+        if add_tags:
+            arglist += ['--tag', 'red', '--tag', 'blue']
+        else:
+            arglist += ['--no-tag']
+        verifylist = [
+            ('name', self._subnet.name),
+            ('subnet_range', self._subnet.cidr),
+            ('network', self._subnet.network_id),
+            ('ip_version', self._subnet.ip_version),
+            ('gateway', 'auto'),
+        ]
+        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.network.create_subnet.assert_called_once_with(
+            cidr=self._subnet.cidr,
+            ip_version=self._subnet.ip_version,
+            name=self._subnet.name,
+            network_id=self._subnet.network_id)
+        if add_tags:
+            self.network.set_tags.assert_called_once_with(
+                self._subnet,
+                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 TestDeleteSubnet(TestSubnet):
 
@@ -558,7 +580,7 @@ class TestDeleteSubnet(TestSubnet):
         )
 
 
-class TestListSubnet(TestSubnet, _test_tag.TestListTagMixin):
+class TestListSubnet(TestSubnet):
     # The subnets going to be listed up.
     _subnet = network_fakes.FakeSubnet.create_subnets(count=3)
 
@@ -615,9 +637,6 @@ class TestListSubnet(TestSubnet, _test_tag.TestListTagMixin):
 
         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 = [
@@ -837,8 +856,33 @@ class TestListSubnet(TestSubnet, _test_tag.TestListTagMixin):
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, list(data))
 
+    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.network.subnets.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 TestSetSubnet(TestSubnet, _test_tag.TestSetTagMixin):
+class TestSetSubnet(TestSubnet):
 
     _subnet = network_fakes.FakeSubnet.create_one_subnet(
         {'tags': ['green', 'red']})
@@ -849,10 +893,6 @@ class TestSetSubnet(TestSubnet, _test_tag.TestSetTagMixin):
         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 = [
@@ -1001,6 +1041,34 @@ class TestSetSubnet(TestSubnet, _test_tag.TestSetTagMixin):
             _testsubnet, **attrs)
         self.assertIsNone(result)
 
+    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._subnet.name)
+        verifylist.append(
+            ('subnet', self._subnet.name))
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        self.assertFalse(self.network.update_subnet.called)
+        self.network.set_tags.assert_called_once_with(
+            self._subnet,
+            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 TestShowSubnet(TestSubnet):
     # The subnets to be shown
@@ -1083,7 +1151,7 @@ class TestShowSubnet(TestSubnet):
         self.assertEqual(self.data, data)
 
 
-class TestUnsetSubnet(TestSubnet, _test_tag.TestUnsetTagMixin):
+class TestUnsetSubnet(TestSubnet):
 
     def setUp(self):
         super(TestUnsetSubnet, self).setUp()
@@ -1106,10 +1174,6 @@ class TestUnsetSubnet(TestSubnet, _test_tag.TestUnsetTagMixin):
         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 = [
@@ -1219,3 +1283,31 @@ class TestUnsetSubnet(TestSubnet, _test_tag.TestUnsetTagMixin):
         parsed_args = self.check_parser(self.cmd, arglist, verifylist)
         self.assertRaises(exceptions.CommandError,
                           self.cmd.take_action, parsed_args)
+
+    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._testsubnet.name)
+        verifylist.append(
+            ('subnet', self._testsubnet.name))
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        self.assertFalse(self.network.update_subnet.called)
+        self.network.set_tags.assert_called_once_with(
+            self._testsubnet,
+            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/test_subnet_pool.py b/openstackclient/tests/unit/network/v2/test_subnet_pool.py
index af493856..139fddf8 100644
--- a/openstackclient/tests/unit/network/v2/test_subnet_pool.py
+++ b/openstackclient/tests/unit/network/v2/test_subnet_pool.py
@@ -20,7 +20,6 @@ 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
 
@@ -38,7 +37,7 @@ class TestSubnetPool(network_fakes.TestNetworkV2):
         self.domains_mock = self.app.client_manager.identity.domains
 
 
-class TestCreateSubnetPool(TestSubnetPool, _test_tag.TestCreateTagMixin):
+class TestCreateSubnetPool(TestSubnetPool):
 
     project = identity_fakes_v3.FakeProject.create_one_project()
     domain = identity_fakes_v3.FakeDomain.create_one_domain()
@@ -96,22 +95,6 @@ class TestCreateSubnetPool(TestSubnetPool, _test_tag.TestCreateTagMixin):
         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 = []
@@ -313,6 +296,46 @@ class TestCreateSubnetPool(TestSubnetPool, _test_tag.TestCreateTagMixin):
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, data)
 
+    def _test_create_with_tag(self, add_tags=True):
+        arglist = [
+            '--pool-prefix', '10.0.10.0/24',
+            self._subnet_pool.name,
+        ]
+        if add_tags:
+            arglist += ['--tag', 'red', '--tag', 'blue']
+        else:
+            arglist += ['--no-tag']
+        verifylist = [
+            ('prefixes', ['10.0.10.0/24']),
+            ('name', self._subnet_pool.name),
+        ]
+        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.network.create_subnet_pool.assert_called_once_with(
+            prefixes=['10.0.10.0/24'],
+            name=self._subnet_pool.name
+        )
+        if add_tags:
+            self.network.set_tags.assert_called_once_with(
+                self._subnet_pool,
+                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 TestDeleteSubnetPool(TestSubnetPool):
 
@@ -396,7 +419,7 @@ class TestDeleteSubnetPool(TestSubnetPool):
         )
 
 
-class TestListSubnetPool(TestSubnetPool, _test_tag.TestListTagMixin):
+class TestListSubnetPool(TestSubnetPool):
     # The subnet pools going to be listed up.
     _subnet_pools = network_fakes.FakeSubnetPool.create_subnet_pools(count=3)
 
@@ -442,9 +465,6 @@ class TestListSubnetPool(TestSubnetPool, _test_tag.TestListTagMixin):
 
         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 = [
@@ -611,8 +631,33 @@ class TestListSubnetPool(TestSubnetPool, _test_tag.TestListTagMixin):
         self.assertEqual(self.columns, columns)
         self.assertEqual(self.data, list(data))
 
+    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.network.subnet_pools.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 TestSetSubnetPool(TestSubnetPool, _test_tag.TestSetTagMixin):
+
+class TestSetSubnetPool(TestSubnetPool):
 
     # The subnet_pool to set.
     _subnet_pool = network_fakes.FakeSubnetPool.create_one_subnet_pool(
@@ -637,11 +682,6 @@ class TestSetSubnetPool(TestSubnetPool, _test_tag.TestSetTagMixin):
         # 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',
@@ -867,6 +907,34 @@ class TestSetSubnetPool(TestSubnetPool, _test_tag.TestSetTagMixin):
         )
         self.assertIsNone(result)
 
+    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._subnet_pool.name)
+        verifylist.append(
+            ('subnet_pool', self._subnet_pool.name))
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        self.assertFalse(self.network.update_subnet_pool.called)
+        self.network.set_tags.assert_called_once_with(
+            self._subnet_pool,
+            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 TestShowSubnetPool(TestSubnetPool):
 
@@ -943,7 +1011,7 @@ class TestShowSubnetPool(TestSubnetPool):
         self.assertEqual(self.data, data)
 
 
-class TestUnsetSubnetPool(TestSubnetPool, _test_tag.TestUnsetTagMixin):
+class TestUnsetSubnetPool(TestSubnetPool):
 
     def setUp(self):
         super(TestUnsetSubnetPool, self).setUp()
@@ -958,11 +1026,6 @@ class TestUnsetSubnetPool(TestSubnetPool, _test_tag.TestUnsetTagMixin):
         # 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',
@@ -993,3 +1056,31 @@ class TestUnsetSubnetPool(TestSubnetPool, _test_tag.TestUnsetTagMixin):
         self.assertRaises(exceptions.CommandError,
                           self.cmd.take_action,
                           parsed_args)
+
+    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._subnetpool.name)
+        verifylist.append(
+            ('subnet_pool', self._subnetpool.name))
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        self.assertFalse(self.network.update_subnet_pool.called)
+        self.network.set_tags.assert_called_once_with(
+            self._subnetpool,
+            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)