Add support for Network QoS rule commands

Added following commands:
  - network qos rule create --type minimum-bandwidth
                                   dscp-marking
                                   limit-bandwidth
  - network qos rule delete
  - network qos rule list
  - network qos rule set
  - network qos rule show

Closes-Bug: 1609472
Depends-On: I2e8869750024a8ccbc7777b95fe8ef6e26ec0885
Depends-On: Ife549ff6499217ca65e2554be8ef86ea7866b2d8

Change-Id: Ib3e1951f0917f5f23c8d9e0a380d19da2b3af5f0

5 files changed, 1278 insertions, 73 deletions

diff --git a/openstackclient/tests/functional/base.py b/openstackclient/tests/functional/base.py
index 885abc02..fb78ea62 100644
--- a/openstackclient/tests/functional/base.py
+++ b/openstackclient/tests/functional/base.py
@@ -77,6 +77,11 @@ class TestCase(testtools.TestCase):
         if expected not in actual:
             raise Exception(expected + ' not in ' + actual)
 
+    @classmethod
+    def assertsOutputNotNone(cls, observed):
+        if observed is None:
+            raise Exception('No output observed')
+
     def assert_table_structure(self, items, field_names):
         """Verify that all items have keys listed in field_names."""
         for item in items:
diff --git a/openstackclient/tests/functional/network/v2/test_network_qos_rule.py b/openstackclient/tests/functional/network/v2/test_network_qos_rule.py
new file mode 100644
index 00000000..af0c9bac
--- /dev/null
+++ b/openstackclient/tests/functional/network/v2/test_network_qos_rule.py
@@ -0,0 +1,181 @@
+# Copyright (c) 2016, Intel Corporation.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import uuid
+
+from openstackclient.tests.functional import base
+
+
+class NetworkQosRuleTestsMinimumBandwidth(base.TestCase):
+    """Functional tests for QoS minimum bandwidth rule."""
+    RULE_ID = None
+    QOS_POLICY_NAME = 'qos_policy_' + uuid.uuid4().hex
+    MIN_KBPS = 2800
+    MIN_KBPS_MODIFIED = 7500
+    DIRECTION = '--egress'
+    HEADERS = ['ID']
+    FIELDS = ['id']
+    TYPE = 'minimum-bandwidth'
+
+    @classmethod
+    def setUpClass(cls):
+        opts = cls.get_opts(cls.FIELDS)
+        cls.openstack('network qos policy create ' + cls.QOS_POLICY_NAME)
+        cls.RULE_ID = cls.openstack('network qos rule create --type ' +
+                                    cls.TYPE + ' --min-kbps ' +
+                                    str(cls.MIN_KBPS) + ' ' + cls.DIRECTION +
+                                    ' ' + cls.QOS_POLICY_NAME + opts)
+        cls.assertsOutputNotNone(cls.RULE_ID)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('network qos rule delete ' +
+                                   cls.QOS_POLICY_NAME + ' ' + cls.RULE_ID)
+        cls.openstack('network qos policy delete ' + cls.QOS_POLICY_NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_qos_policy_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('network qos rule list '
+                                    + self.QOS_POLICY_NAME + opts)
+        self.assertIn(self.RULE_ID, raw_output)
+
+    def test_qos_policy_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('network qos rule show ' +
+                                    self.QOS_POLICY_NAME + ' ' + self.RULE_ID +
+                                    opts)
+        self.assertEqual(self.RULE_ID, raw_output)
+
+    def test_qos_policy_set(self):
+        self.openstack('network qos rule set --min-kbps ' +
+                       str(self.MIN_KBPS_MODIFIED) + ' ' +
+                       self.QOS_POLICY_NAME + ' ' + self.RULE_ID)
+        opts = self.get_opts(['min_kbps'])
+        raw_output = self.openstack('network qos rule show ' +
+                                    self.QOS_POLICY_NAME + ' ' + self.RULE_ID +
+                                    opts)
+        self.assertEqual(str(self.MIN_KBPS_MODIFIED) + "\n", raw_output)
+
+
+class NetworkQosRuleTestsDSCPMarking(base.TestCase):
+    """Functional tests for QoS DSCP marking rule."""
+    RULE_ID = None
+    QOS_POLICY_NAME = 'qos_policy_' + uuid.uuid4().hex
+    DSCP_MARK = 8
+    DSCP_MARK_MODIFIED = 32
+    HEADERS = ['ID']
+    FIELDS = ['id']
+    TYPE = 'dscp-marking'
+
+    @classmethod
+    def setUpClass(cls):
+        opts = cls.get_opts(cls.FIELDS)
+        cls.openstack('network qos policy create ' + cls.QOS_POLICY_NAME)
+        cls.RULE_ID = cls.openstack('network qos rule create --type ' +
+                                    cls.TYPE + ' --dscp-mark ' +
+                                    str(cls.DSCP_MARK) + ' ' +
+                                    cls.QOS_POLICY_NAME + opts)
+        cls.assertsOutputNotNone(cls.RULE_ID)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('network qos rule delete ' +
+                                   cls.QOS_POLICY_NAME + ' ' + cls.RULE_ID)
+        cls.openstack('network qos policy delete ' + cls.QOS_POLICY_NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_qos_policy_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('network qos rule list '
+                                    + self.QOS_POLICY_NAME + opts)
+        self.assertIn(self.RULE_ID, raw_output)
+
+    def test_qos_policy_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('network qos rule show ' +
+                                    self.QOS_POLICY_NAME + ' ' + self.RULE_ID +
+                                    opts)
+        self.assertEqual(self.RULE_ID, raw_output)
+
+    def test_qos_policy_set(self):
+        self.openstack('network qos rule set --dscp-mark ' +
+                       str(self.DSCP_MARK_MODIFIED) + ' ' +
+                       self.QOS_POLICY_NAME + ' ' + self.RULE_ID)
+        opts = self.get_opts(['dscp_mark'])
+        raw_output = self.openstack('network qos rule show ' +
+                                    self.QOS_POLICY_NAME + ' ' + self.RULE_ID +
+                                    opts)
+        self.assertEqual(str(self.DSCP_MARK_MODIFIED) + "\n", raw_output)
+
+
+class NetworkQosRuleTestsBandwidthLimit(base.TestCase):
+    """Functional tests for QoS bandwidth limit rule."""
+    RULE_ID = None
+    QOS_POLICY_NAME = 'qos_policy_' + uuid.uuid4().hex
+    MAX_KBPS = 10000
+    MAX_KBPS_MODIFIED = 15000
+    MAX_BURST_KBITS = 1400
+    MAX_BURST_KBITS_MODIFIED = 1800
+    HEADERS = ['ID']
+    FIELDS = ['id']
+    TYPE = 'bandwidth-limit'
+
+    @classmethod
+    def setUpClass(cls):
+        opts = cls.get_opts(cls.FIELDS)
+        cls.openstack('network qos policy create ' + cls.QOS_POLICY_NAME)
+        cls.RULE_ID = cls.openstack('network qos rule create --type ' +
+                                    cls.TYPE + ' --max-kbps ' +
+                                    str(cls.MAX_KBPS) + ' --max-burst-kbits ' +
+                                    str(cls.MAX_BURST_KBITS) + ' ' +
+                                    cls.QOS_POLICY_NAME + opts)
+        cls.assertsOutputNotNone(cls.RULE_ID)
+
+    @classmethod
+    def tearDownClass(cls):
+        raw_output = cls.openstack('network qos rule delete ' +
+                                   cls.QOS_POLICY_NAME + ' ' + cls.RULE_ID)
+        cls.openstack('network qos policy delete ' + cls.QOS_POLICY_NAME)
+        cls.assertOutput('', raw_output)
+
+    def test_qos_policy_list(self):
+        opts = self.get_opts(self.HEADERS)
+        raw_output = self.openstack('network qos rule list '
+                                    + self.QOS_POLICY_NAME + opts)
+        self.assertIn(self.RULE_ID, raw_output)
+
+    def test_qos_policy_show(self):
+        opts = self.get_opts(self.FIELDS)
+        raw_output = self.openstack('network qos rule show ' +
+                                    self.QOS_POLICY_NAME + ' ' + self.RULE_ID +
+                                    opts)
+        self.assertEqual(self.RULE_ID, raw_output)
+
+    def test_qos_policy_set(self):
+        self.openstack('network qos rule set --max-kbps ' +
+                       str(self.MAX_KBPS_MODIFIED) + ' --max-burst-kbits ' +
+                       str(self.MAX_BURST_KBITS_MODIFIED) + ' ' +
+                       self.QOS_POLICY_NAME + ' ' + self.RULE_ID)
+        opts = self.get_opts(['max_kbps'])
+        raw_output = self.openstack('network qos rule show ' +
+                                    self.QOS_POLICY_NAME + ' ' + self.RULE_ID +
+                                    opts)
+        self.assertEqual(str(self.MAX_KBPS_MODIFIED) + "\n", raw_output)
+        opts = self.get_opts(['max_burst_kbps'])
+        raw_output = self.openstack('network qos rule show ' +
+                                    self.QOS_POLICY_NAME + ' ' + self.RULE_ID +
+                                    opts)
+        self.assertEqual(str(self.MAX_BURST_KBITS_MODIFIED) + "\n", raw_output)
diff --git a/openstackclient/tests/unit/fakes.py b/openstackclient/tests/unit/fakes.py
index f7cb5676..0732a1ec 100644
--- a/openstackclient/tests/unit/fakes.py
+++ b/openstackclient/tests/unit/fakes.py
@@ -216,6 +216,12 @@ class FakeResource(object):
     def info(self):
         return self._info
 
+    def __getitem__(self, item):
+        return self._info.get(item)
+
+    def get(self, item, default=None):
+        return self._info.get(item, default)
+
 
 class FakeResponse(requests.Response):
 
diff --git a/openstackclient/tests/unit/network/v2/fakes.py b/openstackclient/tests/unit/network/v2/fakes.py
index b931cb55..fe0422fa 100644
--- a/openstackclient/tests/unit/network/v2/fakes.py
+++ b/openstackclient/tests/unit/network/v2/fakes.py
@@ -14,6 +14,8 @@
 import argparse
 import copy
 import mock
+from random import choice
+from random import randint
 import uuid
 
 from openstackclient.tests.unit import fakes
@@ -37,6 +39,15 @@ QUOTA = {
     "l7policy": 5,
 }
 
+RULE_TYPE_BANDWIDTH_LIMIT = 'bandwidth-limit'
+RULE_TYPE_DSCP_MARKING = 'dscp-marking'
+RULE_TYPE_MINIMUM_BANDWIDTH = 'minimum-bandwidth'
+VALID_QOS_RULES = [RULE_TYPE_BANDWIDTH_LIMIT,
+                   RULE_TYPE_DSCP_MARKING,
+                   RULE_TYPE_MINIMUM_BANDWIDTH]
+VALID_DSCP_MARKS = [0, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32,
+                    34, 36, 38, 40, 46, 48, 56]
+
 
 class FakeNetworkV2Client(object):
 
@@ -662,83 +673,90 @@ class FakeNetworkRBAC(object):
         return mock.Mock(side_effect=rbac_policies)
 
 
-class FakeNetworkQosBandwidthLimitRule(object):
-    """Fake one or more QoS bandwidth limit rules."""
+class FakeNetworkQosPolicy(object):
+    """Fake one or more QoS policies."""
 
     @staticmethod
-    def create_one_qos_bandwidth_limit_rule(attrs=None):
-        """Create a fake QoS bandwidth limit rule.
+    def create_one_qos_policy(attrs=None):
+        """Create a fake QoS policy.
 
         :param Dictionary attrs:
             A dictionary with all attributes
         :return:
-            A FakeResource object with id, qos_policy_id, max_kbps and
-            max_burst_kbps attributes.
+            A FakeResource object with name, id, etc.
         """
         attrs = attrs or {}
+        qos_id = attrs.get('id') or 'qos-policy-id-' + uuid.uuid4().hex
+        rule_attrs = {'qos_policy_id': qos_id}
+        rules = [FakeNetworkQosRule.create_one_qos_rule(rule_attrs)]
 
         # Set default attributes.
-        qos_bandwidth_limit_rule_attrs = {
-            'id': 'qos-bandwidth-limit-rule-id-' + uuid.uuid4().hex,
-            'qos_policy_id': 'qos-policy-id-' + uuid.uuid4().hex,
-            'max_kbps': 1500,
-            'max_burst_kbps': 1200,
+        qos_policy_attrs = {
+            'name': 'qos-policy-name-' + uuid.uuid4().hex,
+            'id': qos_id,
+            'tenant_id': 'project-id-' + uuid.uuid4().hex,
+            'shared': False,
+            'description': 'qos-policy-description-' + uuid.uuid4().hex,
+            'rules': rules,
         }
 
         # Overwrite default attributes.
-        qos_bandwidth_limit_rule_attrs.update(attrs)
+        qos_policy_attrs.update(attrs)
 
-        qos_bandwidth_limit_rule = fakes.FakeResource(
-            info=copy.deepcopy(qos_bandwidth_limit_rule_attrs),
+        qos_policy = fakes.FakeResource(
+            info=copy.deepcopy(qos_policy_attrs),
             loaded=True)
 
-        return qos_bandwidth_limit_rule
+        # Set attributes with special mapping in OpenStack SDK.
+        qos_policy.is_shared = qos_policy_attrs['shared']
+        qos_policy.project_id = qos_policy_attrs['tenant_id']
+
+        return qos_policy
 
     @staticmethod
-    def create_qos_bandwidth_limit_rules(attrs=None, count=2):
-        """Create multiple fake QoS bandwidth limit rules.
+    def create_qos_policies(attrs=None, count=2):
+        """Create multiple fake QoS policies.
 
         :param Dictionary attrs:
             A dictionary with all attributes
         :param int count:
-            The number of QoS bandwidth limit rules to fake
+            The number of QoS policies to fake
         :return:
-            A list of FakeResource objects faking the QoS bandwidth limit rules
+            A list of FakeResource objects faking the QoS policies
         """
         qos_policies = []
         for i in range(0, count):
-            qos_policies.append(FakeNetworkQosBandwidthLimitRule.
-                                create_one_qos_bandwidth_limit_rule(attrs))
+            qos_policies.append(
+                FakeNetworkQosPolicy.create_one_qos_policy(attrs))
 
         return qos_policies
 
     @staticmethod
-    def get_qos_bandwidth_limit_rules(qos_rules=None, count=2):
-        """Get a list of faked QoS bandwidth limit rules.
+    def get_qos_policies(qos_policies=None, count=2):
+        """Get an iterable MagicMock object with a list of faked QoS policies.
 
-        If QoS bandwidth limit rules list is provided, then initialize the
-        Mock object with the list. Otherwise create one.
+        If qos policies list is provided, then initialize the Mock object
+        with the list. Otherwise create one.
 
         :param List address scopes:
-            A list of FakeResource objects faking QoS bandwidth limit rules
+            A list of FakeResource objects faking qos policies
         :param int count:
-            The number of QoS bandwidth limit rules to fake
+            The number of QoS policies to fake
         :return:
             An iterable Mock object with side_effect set to a list of faked
-            qos bandwidth limit rules
+            QoS policies
         """
-        if qos_rules is None:
-            qos_rules = (FakeNetworkQosBandwidthLimitRule.
-                         create_qos_bandwidth_limit_rules(count))
-        return mock.Mock(side_effect=qos_rules)
+        if qos_policies is None:
+            qos_policies = FakeNetworkQosPolicy.create_qos_policies(count)
+        return mock.Mock(side_effect=qos_policies)
 
 
-class FakeNetworkQosPolicy(object):
-    """Fake one or more QoS policies."""
+class FakeNetworkQosRule(object):
+    """Fake one or more Network QoS rules."""
 
     @staticmethod
-    def create_one_qos_policy(attrs=None):
-        """Create a fake QoS policy.
+    def create_one_qos_rule(attrs=None):
+        """Create a fake Network QoS rule.
 
         :param Dictionary attrs:
             A dictionary with all attributes
@@ -746,71 +764,69 @@ class FakeNetworkQosPolicy(object):
             A FakeResource object with name, id, etc.
         """
         attrs = attrs or {}
-        qos_id = attrs.get('id') or 'qos-policy-id-' + uuid.uuid4().hex
-        rule_attrs = {'qos_policy_id': qos_id}
-        rules = [
-            FakeNetworkQosBandwidthLimitRule.
-            create_one_qos_bandwidth_limit_rule(rule_attrs)]
 
         # Set default attributes.
-        qos_policy_attrs = {
-            'name': 'qos-policy-name-' + uuid.uuid4().hex,
-            'id': qos_id,
+        type = attrs.get('type') or choice(VALID_QOS_RULES)
+        qos_rule_attrs = {
+            'id': 'qos-rule-id-' + uuid.uuid4().hex,
+            'qos_policy_id': 'qos-policy-id-' + uuid.uuid4().hex,
             'tenant_id': 'project-id-' + uuid.uuid4().hex,
-            'shared': False,
-            'description': 'qos-policy-description-' + uuid.uuid4().hex,
-            'rules': rules,
+            'type': type,
         }
+        if type == RULE_TYPE_BANDWIDTH_LIMIT:
+            qos_rule_attrs['max_kbps'] = randint(1, 10000)
+            qos_rule_attrs['max_burst_kbits'] = randint(1, 10000)
+        elif type == RULE_TYPE_DSCP_MARKING:
+            qos_rule_attrs['dscp_mark'] = choice(VALID_DSCP_MARKS)
+        elif type == RULE_TYPE_MINIMUM_BANDWIDTH:
+            qos_rule_attrs['min_kbps'] = randint(1, 10000)
+            qos_rule_attrs['direction'] = 'egress'
 
         # Overwrite default attributes.
-        qos_policy_attrs.update(attrs)
+        qos_rule_attrs.update(attrs)
 
-        qos_policy = fakes.FakeResource(
-            info=copy.deepcopy(qos_policy_attrs),
-            loaded=True)
+        qos_rule = fakes.FakeResource(info=copy.deepcopy(qos_rule_attrs),
+                                      loaded=True)
 
         # Set attributes with special mapping in OpenStack SDK.
-        qos_policy.is_shared = qos_policy_attrs['shared']
-        qos_policy.project_id = qos_policy_attrs['tenant_id']
+        qos_rule.project_id = qos_rule['tenant_id']
 
-        return qos_policy
+        return qos_rule
 
     @staticmethod
-    def create_qos_policies(attrs=None, count=2):
-        """Create multiple fake QoS policies.
+    def create_qos_rules(attrs=None, count=2):
+        """Create multiple fake Network QoS rules.
 
         :param Dictionary attrs:
             A dictionary with all attributes
         :param int count:
-            The number of QoS policies to fake
+            The number of Network QoS rule to fake
         :return:
-            A list of FakeResource objects faking the QoS policies
+            A list of FakeResource objects faking the Network QoS rules
         """
-        qos_policies = []
+        qos_rules = []
         for i in range(0, count):
-            qos_policies.append(
-                FakeNetworkQosPolicy.create_one_qos_policy(attrs))
-
-        return qos_policies
+            qos_rules.append(FakeNetworkQosRule.create_one_qos_rule(attrs))
+        return qos_rules
 
     @staticmethod
-    def get_qos_policies(qos_policies=None, count=2):
-        """Get an iterable MagicMock object with a list of faked QoS policies.
+    def get_qos_rules(qos_rules=None, count=2):
+        """Get a list of faked Network QoS rules.
 
-        If qos policies list is provided, then initialize the Mock object
-        with the list. Otherwise create one.
+        If Network QoS rules list is provided, then initialize the Mock
+        object with the list. Otherwise create one.
 
         :param List address scopes:
-            A list of FakeResource objects faking qos policies
+            A list of FakeResource objects faking Network QoS rules
         :param int count:
-            The number of QoS policies to fake
+            The number of QoS minimum bandwidth rules to fake
         :return:
             An iterable Mock object with side_effect set to a list of faked
-            QoS policies
+            qos minimum bandwidth rules
         """
-        if qos_policies is None:
-            qos_policies = FakeNetworkQosPolicy.create_qos_policies(count)
-        return mock.Mock(side_effect=qos_policies)
+        if qos_rules is None:
+            qos_rules = (FakeNetworkQosRule.create_qos_rules(count))
+        return mock.Mock(side_effect=qos_rules)
 
 
 class FakeNetworkQosRuleType(object):
diff --git a/openstackclient/tests/unit/network/v2/test_network_qos_rule.py b/openstackclient/tests/unit/network/v2/test_network_qos_rule.py
new file mode 100644
index 00000000..e66f25b7
--- /dev/null
+++ b/openstackclient/tests/unit/network/v2/test_network_qos_rule.py
@@ -0,0 +1,997 @@
+# Copyright (c) 2016, Intel Corporation.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import mock
+
+from osc_lib import exceptions
+
+from openstackclient.network.v2 import network_qos_rule
+from openstackclient.tests.unit.network.v2 import fakes as network_fakes
+from openstackclient.tests.unit import utils as tests_utils
+
+
+RULE_TYPE_BANDWIDTH_LIMIT = 'bandwidth-limit'
+RULE_TYPE_DSCP_MARKING = 'dscp-marking'
+RULE_TYPE_MINIMUM_BANDWIDTH = 'minimum-bandwidth'
+DSCP_VALID_MARKS = [0, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32,
+                    34, 36, 38, 40, 46, 48, 56]
+
+
+class TestNetworkQosRule(network_fakes.TestNetworkV2):
+
+    def setUp(self):
+        super(TestNetworkQosRule, self).setUp()
+        # Get a shortcut to the network client
+        self.network = self.app.client_manager.network
+        self.qos_policy = (network_fakes.FakeNetworkQosPolicy.
+                           create_one_qos_policy())
+        self.network.find_qos_policy = mock.Mock(return_value=self.qos_policy)
+
+
+class TestCreateNetworkQosRuleMinimumBandwidth(TestNetworkQosRule):
+
+    def test_check_type_parameters(self):
+        pass
+
+    def setUp(self):
+        super(TestCreateNetworkQosRuleMinimumBandwidth, self).setUp()
+        attrs = {'qos_policy_id': self.qos_policy.id,
+                 'type': RULE_TYPE_MINIMUM_BANDWIDTH}
+        self.new_rule = network_fakes.FakeNetworkQosRule.create_one_qos_rule(
+            attrs)
+        self.columns = (
+            'direction',
+            'id',
+            'min_kbps',
+            'project_id',
+            'qos_policy_id',
+            'type'
+        )
+
+        self.data = (
+            self.new_rule.direction,
+            self.new_rule.id,
+            self.new_rule.min_kbps,
+            self.new_rule.project_id,
+            self.new_rule.qos_policy_id,
+            self.new_rule.type,
+        )
+        self.network.create_qos_minimum_bandwidth_rule = mock.Mock(
+            return_value=self.new_rule)
+
+        # Get the command object to test
+        self.cmd = network_qos_rule.CreateNetworkQosRule(self.app,
+                                                         self.namespace)
+
+    def test_create_no_options(self):
+        arglist = []
+        verifylist = []
+
+        # Missing required args should bail here
+        self.assertRaises(tests_utils.ParserException, self.check_parser,
+                          self.cmd, arglist, verifylist)
+
+    def test_create_default_options(self):
+        arglist = [
+            '--type', RULE_TYPE_MINIMUM_BANDWIDTH,
+            '--min-kbps', str(self.new_rule.min_kbps),
+            '--egress',
+            self.new_rule.qos_policy_id,
+        ]
+
+        verifylist = [
+            ('type', RULE_TYPE_MINIMUM_BANDWIDTH),
+            ('min_kbps', self.new_rule.min_kbps),
+            ('egress', True),
+            ('qos_policy', self.new_rule.qos_policy_id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        columns, data = (self.cmd.take_action(parsed_args))
+
+        self.network.create_qos_minimum_bandwidth_rule.assert_called_once_with(
+            self.qos_policy.id,
+            **{'min_kbps': self.new_rule.min_kbps,
+               'direction': self.new_rule.direction}
+        )
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
+
+    def test_create_wrong_options(self):
+        arglist = [
+            '--type', RULE_TYPE_MINIMUM_BANDWIDTH,
+            '--max-kbps', '10000',
+            self.new_rule.qos_policy_id,
+        ]
+
+        verifylist = [
+            ('type', RULE_TYPE_MINIMUM_BANDWIDTH),
+            ('max_kbps', 10000),
+            ('qos_policy', self.new_rule.qos_policy_id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        try:
+            self.cmd.take_action(parsed_args)
+        except exceptions.CommandError as e:
+            msg = ('"Create" rule command for type "minimum-bandwidth" '
+                   'requires arguments min_kbps, direction')
+            self.assertEqual(msg, str(e))
+
+
+class TestCreateNetworkQosRuleDSCPMarking(TestNetworkQosRule):
+
+    def test_check_type_parameters(self):
+        pass
+
+    def setUp(self):
+        super(TestCreateNetworkQosRuleDSCPMarking, self).setUp()
+        attrs = {'qos_policy_id': self.qos_policy.id,
+                 'type': RULE_TYPE_DSCP_MARKING}
+        self.new_rule = network_fakes.FakeNetworkQosRule.create_one_qos_rule(
+            attrs)
+        self.columns = (
+            'dscp_mark',
+            'id',
+            'project_id',
+            'qos_policy_id',
+            'type'
+        )
+
+        self.data = (
+            self.new_rule.dscp_mark,
+            self.new_rule.id,
+            self.new_rule.project_id,
+            self.new_rule.qos_policy_id,
+            self.new_rule.type,
+        )
+        self.network.create_qos_dscp_marking_rule = mock.Mock(
+            return_value=self.new_rule)
+
+        # Get the command object to test
+        self.cmd = network_qos_rule.CreateNetworkQosRule(self.app,
+                                                         self.namespace)
+
+    def test_create_no_options(self):
+        arglist = []
+        verifylist = []
+
+        # Missing required args should bail here
+        self.assertRaises(tests_utils.ParserException, self.check_parser,
+                          self.cmd, arglist, verifylist)
+
+    def test_create_default_options(self):
+        arglist = [
+            '--type', RULE_TYPE_DSCP_MARKING,
+            '--dscp-mark', str(self.new_rule.dscp_mark),
+            self.new_rule.qos_policy_id,
+        ]
+
+        verifylist = [
+            ('type', RULE_TYPE_DSCP_MARKING),
+            ('dscp_mark', self.new_rule.dscp_mark),
+            ('qos_policy', self.new_rule.qos_policy_id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.network.create_qos_dscp_marking_rule.assert_called_once_with(
+            self.qos_policy.id,
+            **{'dscp_mark': self.new_rule.dscp_mark}
+        )
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
+
+    def test_create_wrong_options(self):
+        arglist = [
+            '--type', RULE_TYPE_DSCP_MARKING,
+            '--max-kbps', '10000',
+            self.new_rule.qos_policy_id,
+        ]
+
+        verifylist = [
+            ('type', RULE_TYPE_DSCP_MARKING),
+            ('max_kbps', 10000),
+            ('qos_policy', self.new_rule.qos_policy_id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        try:
+            self.cmd.take_action(parsed_args)
+        except exceptions.CommandError as e:
+            msg = ('"Create" rule command for type "dscp-marking" '
+                   'requires arguments dscp_mark')
+            self.assertEqual(msg, str(e))
+
+
+class TestCreateNetworkQosRuleBandwidtLimit(TestNetworkQosRule):
+
+    def test_check_type_parameters(self):
+        pass
+
+    def setUp(self):
+        super(TestCreateNetworkQosRuleBandwidtLimit, self).setUp()
+        attrs = {'qos_policy_id': self.qos_policy.id,
+                 'type': RULE_TYPE_BANDWIDTH_LIMIT}
+        self.new_rule = network_fakes.FakeNetworkQosRule.create_one_qos_rule(
+            attrs)
+        self.columns = (
+            'id',
+            'max_burst_kbits',
+            'max_kbps',
+            'project_id',
+            'qos_policy_id',
+            'type'
+        )
+
+        self.data = (
+            self.new_rule.id,
+            self.new_rule.max_burst_kbits,
+            self.new_rule.max_kbps,
+            self.new_rule.project_id,
+            self.new_rule.qos_policy_id,
+            self.new_rule.type,
+        )
+        self.network.create_qos_bandwidth_limit_rule = mock.Mock(
+            return_value=self.new_rule)
+
+        # Get the command object to test
+        self.cmd = network_qos_rule.CreateNetworkQosRule(self.app,
+                                                         self.namespace)
+
+    def test_create_no_options(self):
+        arglist = []
+        verifylist = []
+
+        # Missing required args should bail here
+        self.assertRaises(tests_utils.ParserException, self.check_parser,
+                          self.cmd, arglist, verifylist)
+
+    def test_create_default_options(self):
+        arglist = [
+            '--type', RULE_TYPE_BANDWIDTH_LIMIT,
+            '--max-kbps', str(self.new_rule.max_kbps),
+            '--max-burst-kbits', str(self.new_rule.max_burst_kbits),
+            self.new_rule.qos_policy_id,
+        ]
+
+        verifylist = [
+            ('type', RULE_TYPE_BANDWIDTH_LIMIT),
+            ('max_kbps', self.new_rule.max_kbps),
+            ('max_burst_kbits', self.new_rule.max_burst_kbits),
+            ('qos_policy', self.new_rule.qos_policy_id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        columns, data = (self.cmd.take_action(parsed_args))
+
+        self.network.create_qos_bandwidth_limit_rule.assert_called_once_with(
+            self.qos_policy.id,
+            **{'max_kbps': self.new_rule.max_kbps,
+               'max_burst_kbps': self.new_rule.max_burst_kbits}
+        )
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(self.data, data)
+
+    def test_create_wrong_options(self):
+        arglist = [
+            '--type', RULE_TYPE_BANDWIDTH_LIMIT,
+            '--min-kbps', '10000',
+            self.new_rule.qos_policy_id,
+        ]
+
+        verifylist = [
+            ('type', RULE_TYPE_BANDWIDTH_LIMIT),
+            ('min_kbps', 10000),
+            ('qos_policy', self.new_rule.qos_policy_id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        try:
+            self.cmd.take_action(parsed_args)
+        except exceptions.CommandError as e:
+            msg = ('"Create" rule command for type "bandwidth-limit" '
+                   'requires arguments max_kbps, max_burst_kbps')
+            self.assertEqual(msg, str(e))
+
+
+class TestDeleteNetworkQosRuleMinimumBandwidth(TestNetworkQosRule):
+
+    def setUp(self):
+        super(TestDeleteNetworkQosRuleMinimumBandwidth, self).setUp()
+        attrs = {'qos_policy_id': self.qos_policy.id,
+                 'type': RULE_TYPE_MINIMUM_BANDWIDTH}
+        self.new_rule = network_fakes.FakeNetworkQosRule.create_one_qos_rule(
+            attrs)
+        self.qos_policy.rules = [self.new_rule]
+        self.network.delete_qos_minimum_bandwidth_rule = mock.Mock(
+            return_value=None)
+        self.network.find_qos_minimum_bandwidth_rule = (
+            network_fakes.FakeNetworkQosRule.get_qos_rules(
+                qos_rules=self.new_rule)
+        )
+
+        # Get the command object to test
+        self.cmd = network_qos_rule.DeleteNetworkQosRule(self.app,
+                                                         self.namespace)
+
+    def test_qos_policy_delete(self):
+        arglist = [
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+        self.network.find_qos_policy.assert_called_once_with(
+            self.qos_policy.id, ignore_missing=False)
+        self.network.delete_qos_minimum_bandwidth_rule.assert_called_once_with(
+            self.new_rule.id, self.qos_policy.id)
+        self.assertIsNone(result)
+
+    def test_qos_policy_delete_error(self):
+        arglist = [
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        self.network.delete_qos_minimum_bandwidth_rule.side_effect = \
+            Exception('Error message')
+        try:
+            parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+            self.cmd.take_action(parsed_args)
+        except exceptions.CommandError as e:
+            msg = ('Failed to delete Network QoS rule ID "%(rule)s": %(e)s' %
+                   {'rule': self.new_rule.id, 'e': 'Error message'})
+            self.assertEqual(msg, str(e))
+
+
+class TestDeleteNetworkQosRuleDSCPMarking(TestNetworkQosRule):
+
+    def setUp(self):
+        super(TestDeleteNetworkQosRuleDSCPMarking, self).setUp()
+        attrs = {'qos_policy_id': self.qos_policy.id,
+                 'type': RULE_TYPE_DSCP_MARKING}
+        self.new_rule = network_fakes.FakeNetworkQosRule.create_one_qos_rule(
+            attrs)
+        self.qos_policy.rules = [self.new_rule]
+        self.network.delete_qos_dscp_marking_rule = mock.Mock(
+            return_value=None)
+        self.network.find_qos_dscp_marking_rule = (
+            network_fakes.FakeNetworkQosRule.get_qos_rules(
+                qos_rules=self.new_rule)
+        )
+
+        # Get the command object to test
+        self.cmd = network_qos_rule.DeleteNetworkQosRule(self.app,
+                                                         self.namespace)
+
+    def test_qos_policy_delete(self):
+        arglist = [
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+        self.network.find_qos_policy.assert_called_once_with(
+            self.qos_policy.id, ignore_missing=False)
+        self.network.delete_qos_dscp_marking_rule.assert_called_once_with(
+            self.new_rule.id, self.qos_policy.id)
+        self.assertIsNone(result)
+
+    def test_qos_policy_delete_error(self):
+        arglist = [
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        self.network.delete_qos_dscp_marking_rule.side_effect = \
+            Exception('Error message')
+        try:
+            parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+            self.cmd.take_action(parsed_args)
+        except exceptions.CommandError as e:
+            msg = ('Failed to delete Network QoS rule ID "%(rule)s": %(e)s' %
+                   {'rule': self.new_rule.id, 'e': 'Error message'})
+            self.assertEqual(msg, str(e))
+
+
+class TestDeleteNetworkQosRuleBandwidthLimit(TestNetworkQosRule):
+
+    def setUp(self):
+        super(TestDeleteNetworkQosRuleBandwidthLimit, self).setUp()
+        attrs = {'qos_policy_id': self.qos_policy.id,
+                 'type': RULE_TYPE_BANDWIDTH_LIMIT}
+        self.new_rule = network_fakes.FakeNetworkQosRule.create_one_qos_rule(
+            attrs)
+        self.qos_policy.rules = [self.new_rule]
+        self.network.delete_qos_bandwidth_limit_rule = mock.Mock(
+            return_value=None)
+        self.network.find_qos_bandwidth_limit_rule = (
+            network_fakes.FakeNetworkQosRule.get_qos_rules(
+                qos_rules=self.new_rule)
+        )
+
+        # Get the command object to test
+        self.cmd = network_qos_rule.DeleteNetworkQosRule(self.app,
+                                                         self.namespace)
+
+    def test_qos_policy_delete(self):
+        arglist = [
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+        self.network.find_qos_policy.assert_called_once_with(
+            self.qos_policy.id, ignore_missing=False)
+        self.network.delete_qos_bandwidth_limit_rule.assert_called_once_with(
+            self.new_rule.id, self.qos_policy.id)
+        self.assertIsNone(result)
+
+    def test_qos_policy_delete_error(self):
+        arglist = [
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        self.network.delete_qos_bandwidth_limit_rule.side_effect = \
+            Exception('Error message')
+        try:
+            parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+            self.cmd.take_action(parsed_args)
+        except exceptions.CommandError as e:
+            msg = ('Failed to delete Network QoS rule ID "%(rule)s": %(e)s' %
+                   {'rule': self.new_rule.id, 'e': 'Error message'})
+            self.assertEqual(msg, str(e))
+
+
+class TestSetNetworkQosRuleMinimumBandwidth(TestNetworkQosRule):
+
+    def setUp(self):
+        super(TestSetNetworkQosRuleMinimumBandwidth, self).setUp()
+        attrs = {'qos_policy_id': self.qos_policy.id,
+                 'type': RULE_TYPE_MINIMUM_BANDWIDTH}
+        self.new_rule = network_fakes.FakeNetworkQosRule.create_one_qos_rule(
+            attrs=attrs)
+        self.qos_policy.rules = [self.new_rule]
+        self.network.update_qos_minimum_bandwidth_rule = mock.Mock(
+            return_value=None)
+        self.network.find_qos_minimum_bandwidth_rule = mock.Mock(
+            return_value=self.new_rule)
+        self.network.find_qos_policy = mock.Mock(
+            return_value=self.qos_policy)
+
+        # Get the command object to test
+        self.cmd = (network_qos_rule.SetNetworkQosRule(self.app,
+                                                       self.namespace))
+
+    def test_set_nothing(self):
+        arglist = [
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        self.network.update_qos_minimum_bandwidth_rule.assert_called_with(
+            self.new_rule, self.qos_policy.id)
+        self.assertIsNone(result)
+
+    def test_set_min_kbps(self):
+        arglist = [
+            '--min-kbps', str(self.new_rule.min_kbps),
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('min_kbps', self.new_rule.min_kbps),
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        attrs = {
+            'min_kbps': self.new_rule.min_kbps,
+        }
+        self.network.update_qos_minimum_bandwidth_rule.assert_called_with(
+            self.new_rule, self.qos_policy.id, **attrs)
+        self.assertIsNone(result)
+
+    def test_set_wrong_options(self):
+        arglist = [
+            '--max-kbps', str(10000),
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('max_kbps', 10000),
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        try:
+            self.cmd.take_action(parsed_args)
+        except exceptions.CommandError as e:
+            msg = ('Failed to set Network QoS rule ID "%(rule)s": Rule type '
+                   '"minimum-bandwidth" only requires arguments min_kbps, '
+                   'direction' % {'rule': self.new_rule.id})
+            self.assertEqual(msg, str(e))
+
+
+class TestSetNetworkQosRuleDSCPMarking(TestNetworkQosRule):
+
+    def setUp(self):
+        super(TestSetNetworkQosRuleDSCPMarking, self).setUp()
+        attrs = {'qos_policy_id': self.qos_policy.id,
+                 'type': RULE_TYPE_DSCP_MARKING}
+        self.new_rule = network_fakes.FakeNetworkQosRule.create_one_qos_rule(
+            attrs=attrs)
+        self.qos_policy.rules = [self.new_rule]
+        self.network.update_qos_dscp_marking_rule = mock.Mock(
+            return_value=None)
+        self.network.find_qos_dscp_marking_rule = mock.Mock(
+            return_value=self.new_rule)
+        self.network.find_qos_policy = mock.Mock(
+            return_value=self.qos_policy)
+
+        # Get the command object to test
+        self.cmd = (network_qos_rule.SetNetworkQosRule(self.app,
+                                                       self.namespace))
+
+    def test_set_nothing(self):
+        arglist = [
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        self.network.update_qos_dscp_marking_rule.assert_called_with(
+            self.new_rule, self.qos_policy.id)
+        self.assertIsNone(result)
+
+    def test_set_dscp_mark(self):
+        arglist = [
+            '--dscp-mark', str(self.new_rule.dscp_mark),
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('dscp_mark', self.new_rule.dscp_mark),
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        attrs = {
+            'dscp_mark': self.new_rule.dscp_mark,
+        }
+        self.network.update_qos_dscp_marking_rule.assert_called_with(
+            self.new_rule, self.qos_policy.id, **attrs)
+        self.assertIsNone(result)
+
+    def test_set_wrong_options(self):
+        arglist = [
+            '--max-kbps', str(10000),
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('max_kbps', 10000),
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        try:
+            self.cmd.take_action(parsed_args)
+        except exceptions.CommandError as e:
+            msg = ('Failed to set Network QoS rule ID "%(rule)s": Rule type '
+                   '"dscp-marking" only requires arguments dscp_mark' %
+                   {'rule': self.new_rule.id})
+            self.assertEqual(msg, str(e))
+
+
+class TestSetNetworkQosRuleBandwidthLimit(TestNetworkQosRule):
+
+    def setUp(self):
+        super(TestSetNetworkQosRuleBandwidthLimit, self).setUp()
+        attrs = {'qos_policy_id': self.qos_policy.id,
+                 'type': RULE_TYPE_BANDWIDTH_LIMIT}
+        self.new_rule = network_fakes.FakeNetworkQosRule.create_one_qos_rule(
+            attrs=attrs)
+        self.qos_policy.rules = [self.new_rule]
+        self.network.update_qos_bandwidth_limit_rule = mock.Mock(
+            return_value=None)
+        self.network.find_qos_bandwidth_limit_rule = mock.Mock(
+            return_value=self.new_rule)
+        self.network.find_qos_policy = mock.Mock(
+            return_value=self.qos_policy)
+
+        # Get the command object to test
+        self.cmd = (network_qos_rule.SetNetworkQosRule(self.app,
+                                                       self.namespace))
+
+    def test_set_nothing(self):
+        arglist = [
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        self.network.update_qos_bandwidth_limit_rule.assert_called_with(
+            self.new_rule, self.qos_policy.id)
+        self.assertIsNone(result)
+
+    def test_set_max_kbps(self):
+        arglist = [
+            '--max-kbps', str(self.new_rule.max_kbps),
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('max_kbps', self.new_rule.max_kbps),
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        attrs = {
+            'max_kbps': self.new_rule.max_kbps,
+        }
+        self.network.update_qos_bandwidth_limit_rule.assert_called_with(
+            self.new_rule, self.qos_policy.id, **attrs)
+        self.assertIsNone(result)
+
+    def test_set_max_burst_kbits(self):
+        arglist = [
+            '--max-burst-kbits', str(self.new_rule.max_burst_kbits),
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('max_burst_kbits', self.new_rule.max_burst_kbits),
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        result = self.cmd.take_action(parsed_args)
+
+        attrs = {
+            'max_burst_kbps': self.new_rule.max_burst_kbits,
+        }
+        self.network.update_qos_bandwidth_limit_rule.assert_called_with(
+            self.new_rule, self.qos_policy.id, **attrs)
+        self.assertIsNone(result)
+
+    def test_set_wrong_options(self):
+        arglist = [
+            '--min-kbps', str(10000),
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('min_kbps', 10000),
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        try:
+            self.cmd.take_action(parsed_args)
+        except exceptions.CommandError as e:
+            msg = ('Failed to set Network QoS rule ID "%(rule)s": Rule type '
+                   '"bandwidth-limit" only requires arguments max_kbps, '
+                   'max_burst_kbps' % {'rule': self.new_rule.id})
+            self.assertEqual(msg, str(e))
+
+
+class TestListNetworkQosRule(TestNetworkQosRule):
+
+    def setUp(self):
+        super(TestListNetworkQosRule, self).setUp()
+        attrs = {'qos_policy_id': self.qos_policy.id,
+                 'type': RULE_TYPE_MINIMUM_BANDWIDTH}
+        self.new_rule_min_bw = (network_fakes.FakeNetworkQosRule.
+                                create_one_qos_rule(attrs=attrs))
+        attrs['type'] = RULE_TYPE_DSCP_MARKING
+        self.new_rule_dscp_mark = (network_fakes.FakeNetworkQosRule.
+                                   create_one_qos_rule(attrs=attrs))
+        attrs['type'] = RULE_TYPE_BANDWIDTH_LIMIT
+        self.new_rule_max_bw = (network_fakes.FakeNetworkQosRule.
+                                create_one_qos_rule(attrs=attrs))
+        self.qos_policy.rules = [self.new_rule_min_bw,
+                                 self.new_rule_dscp_mark,
+                                 self.new_rule_max_bw]
+        self.network.find_qos_minimum_bandwidth_rule = mock.Mock(
+            return_value=self.new_rule_min_bw)
+        self.network.find_qos_dscp_marking_rule = mock.Mock(
+            return_value=self.new_rule_dscp_mark)
+        self.network.find_qos_bandwidth_limit_rule = mock.Mock(
+            return_value=self.new_rule_max_bw)
+        self.columns = (
+            'ID',
+            'QoS Policy ID',
+            'Type',
+            'Max Kbps',
+            'Max Burst Kbits',
+            'Min Kbps',
+            'DSCP mark',
+            'Direction',
+        )
+        self.data = []
+        for index in range(len(self.qos_policy.rules)):
+            self.data.append((
+                self.qos_policy.rules[index].id,
+                self.qos_policy.rules[index].qos_policy_id,
+                self.qos_policy.rules[index].type,
+                getattr(self.qos_policy.rules[index], 'max_kbps', ''),
+                getattr(self.qos_policy.rules[index], 'max_burst_kbps', ''),
+                getattr(self.qos_policy.rules[index], 'min_kbps', ''),
+                getattr(self.qos_policy.rules[index], 'dscp_mark', ''),
+                getattr(self.qos_policy.rules[index], 'direction', ''),
+            ))
+        # Get the command object to test
+        self.cmd = network_qos_rule.ListNetworkQosRule(self.app,
+                                                       self.namespace)
+
+    def test_qos_rule_list(self):
+        arglist = [
+            self.qos_policy.id
+        ]
+        verifylist = [
+            ('qos_policy', self.qos_policy.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.network.find_qos_policy.assert_called_once_with(
+            self.qos_policy.id, ignore_missing=False)
+        self.assertEqual(self.columns, columns)
+        list_data = list(data)
+        self.assertEqual(len(self.data), len(list_data))
+        for index in range(len(list_data)):
+            self.assertEqual(self.data[index], list_data[index])
+
+
+class TestShowNetworkQosRuleMinimumBandwidth(TestNetworkQosRule):
+
+    def setUp(self):
+        super(TestShowNetworkQosRuleMinimumBandwidth, self).setUp()
+        attrs = {'qos_policy_id': self.qos_policy.id,
+                 'type': RULE_TYPE_MINIMUM_BANDWIDTH}
+        self.new_rule = network_fakes.FakeNetworkQosRule.create_one_qos_rule(
+            attrs)
+        self.qos_policy.rules = [self.new_rule]
+        self.columns = (
+            'direction',
+            'id',
+            'min_kbps',
+            'project_id',
+            'qos_policy_id',
+            'type'
+        )
+        self.data = (
+            self.new_rule.direction,
+            self.new_rule.id,
+            self.new_rule.min_kbps,
+            self.new_rule.project_id,
+            self.new_rule.qos_policy_id,
+            self.new_rule.type,
+        )
+
+        self.network.get_qos_minimum_bandwidth_rule = mock.Mock(
+            return_value=self.new_rule)
+
+        # Get the command object to test
+        self.cmd = network_qos_rule.ShowNetworkQosRule(self.app,
+                                                       self.namespace)
+
+    def test_show_no_options(self):
+        arglist = []
+        verifylist = []
+
+        # Missing required args should bail here
+        self.assertRaises(tests_utils.ParserException, self.check_parser,
+                          self.cmd, arglist, verifylist)
+
+    def test_show_all_options(self):
+        arglist = [
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.network.get_qos_minimum_bandwidth_rule.assert_called_once_with(
+            self.new_rule.id, self.qos_policy.id)
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(list(self.data), list(data))
+
+
+class TestShowNetworkQosDSCPMarking(TestNetworkQosRule):
+
+    def setUp(self):
+        super(TestShowNetworkQosDSCPMarking, self).setUp()
+        attrs = {'qos_policy_id': self.qos_policy.id,
+                 'type': RULE_TYPE_DSCP_MARKING}
+        self.new_rule = network_fakes.FakeNetworkQosRule.create_one_qos_rule(
+            attrs)
+        self.qos_policy.rules = [self.new_rule]
+        self.columns = (
+            'dscp_mark',
+            'id',
+            'project_id',
+            'qos_policy_id',
+            'type'
+        )
+        self.data = (
+            self.new_rule.dscp_mark,
+            self.new_rule.id,
+            self.new_rule.project_id,
+            self.new_rule.qos_policy_id,
+            self.new_rule.type,
+        )
+
+        self.network.get_qos_dscp_marking_rule = mock.Mock(
+            return_value=self.new_rule)
+
+        # Get the command object to test
+        self.cmd = network_qos_rule.ShowNetworkQosRule(self.app,
+                                                       self.namespace)
+
+    def test_show_no_options(self):
+        arglist = []
+        verifylist = []
+
+        # Missing required args should bail here
+        self.assertRaises(tests_utils.ParserException, self.check_parser,
+                          self.cmd, arglist, verifylist)
+
+    def test_show_all_options(self):
+        arglist = [
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.network.get_qos_dscp_marking_rule.assert_called_once_with(
+            self.new_rule.id, self.qos_policy.id)
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(list(self.data), list(data))
+
+
+class TestShowNetworkQosBandwidthLimit(TestNetworkQosRule):
+
+    def setUp(self):
+        super(TestShowNetworkQosBandwidthLimit, self).setUp()
+        attrs = {'qos_policy_id': self.qos_policy.id,
+                 'type': RULE_TYPE_BANDWIDTH_LIMIT}
+        self.new_rule = network_fakes.FakeNetworkQosRule.create_one_qos_rule(
+            attrs)
+        self.qos_policy.rules = [self.new_rule]
+        self.columns = (
+            'id',
+            'max_burst_kbits',
+            'max_kbps',
+            'project_id',
+            'qos_policy_id',
+            'type'
+        )
+        self.data = (
+            self.new_rule.id,
+            self.new_rule.max_burst_kbits,
+            self.new_rule.max_kbps,
+            self.new_rule.project_id,
+            self.new_rule.qos_policy_id,
+            self.new_rule.type,
+        )
+
+        self.network.get_qos_bandwidth_limit_rule = mock.Mock(
+            return_value=self.new_rule)
+
+        # Get the command object to test
+        self.cmd = network_qos_rule.ShowNetworkQosRule(self.app,
+                                                       self.namespace)
+
+    def test_show_no_options(self):
+        arglist = []
+        verifylist = []
+
+        # Missing required args should bail here
+        self.assertRaises(tests_utils.ParserException, self.check_parser,
+                          self.cmd, arglist, verifylist)
+
+    def test_show_all_options(self):
+        arglist = [
+            self.new_rule.qos_policy_id,
+            self.new_rule.id,
+        ]
+        verifylist = [
+            ('qos_policy', self.new_rule.qos_policy_id),
+            ('id', self.new_rule.id),
+        ]
+
+        parsed_args = self.check_parser(self.cmd, arglist, verifylist)
+        columns, data = self.cmd.take_action(parsed_args)
+
+        self.network.get_qos_bandwidth_limit_rule.assert_called_once_with(
+            self.new_rule.id, self.qos_policy.id)
+        self.assertEqual(self.columns, columns)
+        self.assertEqual(list(self.data), list(data))