Refactor remote command execution in pktgen

Some remote commands in Pktgen are executed without checking the exit
status. This patch makes all remote commands check exit value, and
removes unused variables that are captured from remote command
executions.

JIRA: YARDSTICK-1166

Change-Id: I42a667ebd22d086887d61e1671bc569b03c59d33
Signed-off-by: Miikka Koistinen <miikka.koistinen@nokia.com>

4 files changed, 107 insertions, 133 deletions

diff --git a/yardstick/benchmark/scenarios/networking/pktgen.py b/yardstick/benchmark/scenarios/networking/pktgen.py
index d1d500ff6..c78108adb 100644
--- a/yardstick/benchmark/scenarios/networking/pktgen.py
+++ b/yardstick/benchmark/scenarios/networking/pktgen.py
@@ -112,18 +112,14 @@ class Pktgen(base.Scenario):
     def _get_vnic_driver_name(self):
         cmd = "readlink /sys/class/net/%s/device/driver" % self.vnic_name
         LOG.debug("Executing command: %s", cmd)
-        status, stdout, stderr = self.server.execute(cmd)
-        if status:
-            raise RuntimeError(stderr)
+        _, stdout, _ = self.server.execute(cmd, raise_on_error=True)
         return os.path.basename(stdout.strip())
 
     def _is_irqbalance_disabled(self):
         """Did we disable irqbalance already in the guest?"""
         is_disabled = False
         cmd = "grep ENABLED /etc/default/irqbalance"
-        status, stdout, stderr = self.server.execute(cmd)
-        if status:
-            raise RuntimeError(stderr)
+        _, stdout, _ = self.server.execute(cmd, raise_on_error=True)
         if "0" in stdout:
             is_disabled = True
 
@@ -132,49 +128,35 @@ class Pktgen(base.Scenario):
     def _disable_irqbalance(self):
         cmd = "sudo sed -i -e 's/ENABLED=\"1\"/ENABLED=\"0\"/g' " \
               "/etc/default/irqbalance"
-        status, _, stderr = self.server.execute(cmd)
-        status, _, stderr = self.client.execute(cmd)
-        if status:
-            raise RuntimeError(stderr)
+        self.server.run(cmd)
+        self.client.run(cmd)
 
         cmd = "sudo service irqbalance stop"
-        status, _, stderr = self.server.execute(cmd)
-        status, _, stderr = self.client.execute(cmd)
-        if status:
-            raise RuntimeError(stderr)
+        self.server.run(cmd)
+        self.client.run(cmd)
 
         cmd = "sudo service irqbalance disable"
-        status, _, stderr = self.server.execute(cmd)
-        status, _, stderr = self.client.execute(cmd)
-        if status:
-            raise RuntimeError(stderr)
+        self.server.run(cmd)
+        self.client.run(cmd)
 
     def _setup_irqmapping_ovs(self, queue_number):
         cmd = "grep 'virtio0-input.0' /proc/interrupts |" \
               "awk '{match($0,/ +[0-9]+/)} " \
               "{print substr($1,RSTART,RLENGTH-1)}'"
-        status, stdout, stderr = self.server.execute(cmd)
-        if status:
-            raise RuntimeError(stderr)
+        _, stdout, _ = self.server.execute(cmd, raise_on_error=True)
 
         cmd = "echo 1 | sudo tee /proc/irq/%s/smp_affinity" % (int(stdout))
-        status, _, stderr = self.server.execute(cmd)
-        status, _, stderr = self.client.execute(cmd)
-        if status:
-            raise RuntimeError(stderr)
+        self.server.run(cmd)
+        self.client.run(cmd)
 
         cmd = "grep 'virtio0-output.0' /proc/interrupts |" \
               "awk '{match($0,/ +[0-9]+/)} " \
               "{print substr($1,RSTART,RLENGTH-1)}'"
-        status, stdout, stderr = self.server.execute(cmd)
-        if status:
-            raise RuntimeError(stderr)
+        _, stdout, _ = self.server.execute(cmd, raise_on_error=True)
 
         cmd = "echo 1 | sudo tee /proc/irq/%s/smp_affinity" % (int(stdout))
-        status, _, stderr = self.server.execute(cmd)
-        status, _, stderr = self.client.execute(cmd)
-        if status:
-            raise RuntimeError(stderr)
+        self.server.run(cmd)
+        self.client.run(cmd)
 
         if queue_number == 1:
             return
@@ -186,44 +168,32 @@ class Pktgen(base.Scenario):
             cmd = "grep 'virtio0-input.%s' /proc/interrupts |" \
                   "awk '{match($0,/ +[0-9]+/)} " \
                   "{print substr($1,RSTART,RLENGTH-1)}'" % (i)
-            status, stdout, stderr = self.server.execute(cmd)
-            if status:
-                raise RuntimeError(stderr)
+            _, stdout, _ = self.server.execute(cmd, raise_on_error=True)
 
             cmd = "echo %s | sudo tee /proc/irq/%s/smp_affinity" \
                 % (smp_affinity_mask, int(stdout))
-            status, _, stderr = self.server.execute(cmd)
-            status, _, stderr = self.client.execute(cmd)
-            if status:
-                raise RuntimeError(stderr)
+            self.server.run(cmd)
+            self.client.run(cmd)
 
             cmd = "grep 'virtio0-output.%s' /proc/interrupts |" \
                   "awk '{match($0,/ +[0-9]+/)} " \
                   "{print substr($1,RSTART,RLENGTH-1)}'" % (i)
-            status, stdout, stderr = self.server.execute(cmd)
-            if status:
-                raise RuntimeError(stderr)
+            _, stdout, _ = self.server.execute(cmd, raise_on_error=True)
 
             cmd = "echo %s | sudo tee /proc/irq/%s/smp_affinity" \
                 % (smp_affinity_mask, int(stdout))
-            status, _, stderr = self.server.execute(cmd)
-            status, _, stderr = self.client.execute(cmd)
-            if status:
-                raise RuntimeError(stderr)
+            self.server.run(cmd)
+            self.client.run(cmd)
 
     def _setup_irqmapping_sriov(self, queue_number):
         cmd = "grep '%s-TxRx-0' /proc/interrupts |" \
               "awk '{match($0,/ +[0-9]+/)} " \
               "{print substr($1,RSTART,RLENGTH-1)}'" % self.vnic_name
-        status, stdout, stderr = self.server.execute(cmd)
-        if status:
-            raise RuntimeError(stderr)
+        _, stdout, _ = self.server.execute(cmd, raise_on_error=True)
 
         cmd = "echo 1 | sudo tee /proc/irq/%s/smp_affinity" % (int(stdout))
-        status, _, stderr = self.server.execute(cmd)
-        status, _, stderr = self.client.execute(cmd)
-        if status:
-            raise RuntimeError(stderr)
+        self.server.run(cmd)
+        self.client.run(cmd)
 
         if queue_number == 1:
             return
@@ -234,24 +204,18 @@ class Pktgen(base.Scenario):
             cmd = "grep '%s-TxRx-%s' /proc/interrupts |" \
                   "awk '{match($0,/ +[0-9]+/)} " \
                   "{print substr($1,RSTART,RLENGTH-1)}'" % (self.vnic_name, i)
-            status, stdout, stderr = self.server.execute(cmd)
-            if status:
-                raise RuntimeError(stderr)
+            _, stdout, _ = self.server.execute(cmd, raise_on_error=True)
 
             cmd = "echo %s | sudo tee /proc/irq/%s/smp_affinity" \
                 % (smp_affinity_mask, int(stdout))
-            status, _, stderr = self.server.execute(cmd)
-            status, _, stderr = self.client.execute(cmd)
-            if status:
-                raise RuntimeError(stderr)
+            self.server.run(cmd)
+            self.client.run(cmd)
 
     def _get_sriov_queue_number(self):
         """Get queue number from server as both VMs are the same"""
         cmd = "grep %s-TxRx- /proc/interrupts | wc -l" % self.vnic_name
         LOG.debug("Executing command: %s", cmd)
-        status, stdout, stderr = self.server.execute(cmd)
-        if status:
-            raise RuntimeError(stderr)
+        _, stdout, _ = self.server.execute(cmd, raise_on_error=True)
         return int(stdout)
 
     def _get_available_queue_number(self):
@@ -259,9 +223,7 @@ class Pktgen(base.Scenario):
         cmd = "sudo ethtool -l %s | grep Combined | head -1 |" \
               "awk '{printf $2}'" % self.vnic_name
         LOG.debug("Executing command: %s", cmd)
-        status, stdout, stderr = self.server.execute(cmd)
-        if status:
-            raise RuntimeError(stderr)
+        _, stdout, _ = self.server.execute(cmd, raise_on_error=True)
         return int(stdout)
 
     def _get_usable_queue_number(self):
@@ -269,9 +231,7 @@ class Pktgen(base.Scenario):
         cmd = "sudo ethtool -l %s | grep Combined | tail -1 |" \
               "awk '{printf $2}'" % self.vnic_name
         LOG.debug("Executing command: %s", cmd)
-        status, stdout, stderr = self.server.execute(cmd)
-        if status:
-            raise RuntimeError(stderr)
+        _, stdout, _ = self.server.execute(cmd, raise_on_error=True)
         return int(stdout)
 
     def _enable_ovs_multiqueue(self):
@@ -282,10 +242,8 @@ class Pktgen(base.Scenario):
             cmd = "sudo ethtool -L %s combined %s" % \
                 (self.vnic_name, available_queue_number)
             LOG.debug("Executing command: %s", cmd)
-            status, _, stderr = self.server.execute(cmd)
-            status, _, stderr = self.client.execute(cmd)
-            if status:
-                raise RuntimeError(stderr)
+            self.server.run(cmd)
+            self.client.run(cmd)
         return available_queue_number
 
     def _iptables_setup(self):
@@ -294,9 +252,7 @@ class Pktgen(base.Scenario):
               "sudo iptables -A INPUT -p udp --dport 1000:%s -j DROP" \
               % (1000 + self.number_of_ports)
         LOG.debug("Executing command: %s", cmd)
-        status, _, stderr = self.server.execute(cmd, timeout=SSH_TIMEOUT)
-        if status:
-            raise RuntimeError(stderr)
+        self.server.run(cmd, timeout=SSH_TIMEOUT)
 
     def _iptables_get_result(self):
         """Get packet statistics from server"""
@@ -304,9 +260,7 @@ class Pktgen(base.Scenario):
               "awk '/dpts:1000:%s/ {{printf \"%%s\", $1}}'" \
               % (1000 + self.number_of_ports)
         LOG.debug("Executing command: %s", cmd)
-        status, stdout, stderr = self.server.execute(cmd)
-        if status:
-            raise RuntimeError(stderr)
+        _, stdout, _ = self.server.execute(cmd, raise_on_error=True)
         return int(stdout)
 
     def run(self, result):
@@ -356,10 +310,8 @@ class Pktgen(base.Scenario):
                duration, queue_number, pps)
 
         LOG.debug("Executing command: %s", cmd)
-        status, stdout, stderr = self.client.execute(cmd, timeout=SSH_TIMEOUT)
-
-        if status:
-            raise RuntimeError(stderr)
+        _, stdout, _ = self.client.execute(cmd, raise_on_error=True,
+                                           timeout=SSH_TIMEOUT)
 
         result.update(jsonutils.loads(stdout))
 
diff --git a/yardstick/ssh.py b/yardstick/ssh.py
index 6b5e6faf4..e6a26ab6b 100644
--- a/yardstick/ssh.py
+++ b/yardstick/ssh.py
@@ -348,12 +348,14 @@ class SSH(object):
             raise exceptions.SSHError(error_msg=details)
         return exit_status
 
-    def execute(self, cmd, stdin=None, timeout=3600):
+    def execute(self, cmd, stdin=None, timeout=3600, raise_on_error=False):
         """Execute the specified command on the server.
 
-        :param cmd:     Command to be executed.
-        :param stdin:   Open file to be sent on process stdin.
-        :param timeout: Timeout for execution of the command.
+        :param cmd: (str)             Command to be executed.
+        :param stdin: (StringIO)      Open file to be sent on process stdin.
+        :param timeout: (int)         Timeout for execution of the command.
+        :param raise_on_error: (bool) If True, then an SSHError will be raised
+                                      when non-zero exit code.
 
         :returns: tuple (exit_status, stdout, stderr)
         """
@@ -362,7 +364,7 @@ class SSH(object):
 
         exit_status = self.run(cmd, stderr=stderr,
                                stdout=stdout, stdin=stdin,
-                               timeout=timeout, raise_on_error=False)
+                               timeout=timeout, raise_on_error=raise_on_error)
         stdout.seek(0)
         stderr.seek(0)
         return exit_status, stdout.read(), stderr.read()
diff --git a/yardstick/tests/unit/benchmark/scenarios/networking/test_pktgen.py b/yardstick/tests/unit/benchmark/scenarios/networking/test_pktgen.py
index ea0deab3e..4016f5055 100644
--- a/yardstick/tests/unit/benchmark/scenarios/networking/test_pktgen.py
+++ b/yardstick/tests/unit/benchmark/scenarios/networking/test_pktgen.py
@@ -56,11 +56,9 @@ class PktgenTestCase(unittest.TestCase):
         p.server = mock_ssh.SSH.from_node()
         p.number_of_ports = args['options']['number_of_ports']
 
-        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
-
         p._iptables_setup()
 
-        mock_ssh.SSH.from_node().execute.assert_called_with(
+        mock_ssh.SSH.from_node().run.assert_called_with(
             "sudo iptables -F; "
             "sudo iptables -A INPUT -p udp --dport 1000:%s -j DROP"
             % 1010, timeout=60)
@@ -75,8 +73,8 @@ class PktgenTestCase(unittest.TestCase):
         p.server = mock_ssh.SSH.from_node()
         p.number_of_ports = args['options']['number_of_ports']
 
-        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
-        self.assertRaises(RuntimeError, p._iptables_setup)
+        mock_ssh.SSH.from_node().run.side_effect = y_exc.SSHError
+        self.assertRaises(y_exc.SSHError, p._iptables_setup)
 
     def test_pktgen_successful_iptables_get_result(self, mock_ssh):
 
@@ -89,12 +87,14 @@ class PktgenTestCase(unittest.TestCase):
         p.number_of_ports = args['options']['number_of_ports']
 
         mock_ssh.SSH.from_node().execute.return_value = (0, '150000', '')
-        p._iptables_get_result()
+        result = p._iptables_get_result()
+        expected_result = 150000
+        self.assertEqual(result, expected_result)
 
         mock_ssh.SSH.from_node().execute.assert_called_with(
             "sudo iptables -L INPUT -vnx |"
             "awk '/dpts:1000:%s/ {{printf \"%%s\", $1}}'"
-            % 1010)
+            % 1010, raise_on_error=True)
 
     def test_pktgen_unsuccessful_iptables_get_result(self, mock_ssh):
 
@@ -107,8 +107,8 @@ class PktgenTestCase(unittest.TestCase):
         p.server = mock_ssh.SSH.from_node()
         p.number_of_ports = args['options']['number_of_ports']
 
-        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
-        self.assertRaises(RuntimeError, p._iptables_get_result)
+        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
+        self.assertRaises(y_exc.SSHError, p._iptables_get_result)
 
     def test_pktgen_successful_no_sla(self, mock_ssh):
 
@@ -192,8 +192,8 @@ class PktgenTestCase(unittest.TestCase):
         p.server = mock_ssh.SSH.from_node()
         p.client = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
-        self.assertRaises(RuntimeError, p.run, result)
+        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
+        self.assertRaises(y_exc.SSHError, p.run, result)
 
     def test_pktgen_get_vnic_driver_name(self, mock_ssh):
         args = {
@@ -214,9 +214,9 @@ class PktgenTestCase(unittest.TestCase):
         p = pktgen.Pktgen(args, self.ctx)
         p.server = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
+        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
 
-        self.assertRaises(RuntimeError, p._get_vnic_driver_name)
+        self.assertRaises(y_exc.SSHError, p._get_vnic_driver_name)
 
     def test_pktgen_get_sriov_queue_number(self, mock_ssh):
         args = {
@@ -237,9 +237,9 @@ class PktgenTestCase(unittest.TestCase):
         p = pktgen.Pktgen(args, self.ctx)
         p.server = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
+        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
 
-        self.assertRaises(RuntimeError, p._get_sriov_queue_number)
+        self.assertRaises(y_exc.SSHError, p._get_sriov_queue_number)
 
     def test_pktgen_get_available_queue_number(self, mock_ssh):
         args = {
@@ -250,11 +250,11 @@ class PktgenTestCase(unittest.TestCase):
 
         mock_ssh.SSH.from_node().execute.return_value = (0, '4', '')
 
-        p._get_available_queue_number()
+        self.assertEqual(p._get_available_queue_number(), 4)
 
         mock_ssh.SSH.from_node().execute.assert_called_with(
             "sudo ethtool -l eth0 | grep Combined | head -1 |"
-            "awk '{printf $2}'")
+            "awk '{printf $2}'", raise_on_error=True)
 
     def test_pktgen_unsuccessful_get_available_queue_number(self, mock_ssh):
         args = {
@@ -263,9 +263,9 @@ class PktgenTestCase(unittest.TestCase):
         p = pktgen.Pktgen(args, self.ctx)
         p.server = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
+        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
 
-        self.assertRaises(RuntimeError, p._get_available_queue_number)
+        self.assertRaises(y_exc.SSHError, p._get_available_queue_number)
 
     def test_pktgen_get_usable_queue_number(self, mock_ssh):
         args = {
@@ -276,11 +276,11 @@ class PktgenTestCase(unittest.TestCase):
 
         mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
 
-        p._get_usable_queue_number()
+        self.assertEqual(p._get_usable_queue_number(), 1)
 
         mock_ssh.SSH.from_node().execute.assert_called_with(
             "sudo ethtool -l eth0 | grep Combined | tail -1 |"
-            "awk '{printf $2}'")
+            "awk '{printf $2}'", raise_on_error=True)
 
     def test_pktgen_unsuccessful_get_usable_queue_number(self, mock_ssh):
         args = {
@@ -289,9 +289,9 @@ class PktgenTestCase(unittest.TestCase):
         p = pktgen.Pktgen(args, self.ctx)
         p.server = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
+        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
 
-        self.assertRaises(RuntimeError, p._get_usable_queue_number)
+        self.assertRaises(y_exc.SSHError, p._get_usable_queue_number)
 
     def test_pktgen_enable_ovs_multiqueue(self, mock_ssh):
         args = {
@@ -333,12 +333,12 @@ class PktgenTestCase(unittest.TestCase):
         p.server = mock_ssh.SSH.from_node()
         p.client = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
+        mock_ssh.SSH.from_node().run.side_effect = y_exc.SSHError
 
         p._get_usable_queue_number = mock.Mock(return_value=1)
         p._get_available_queue_number = mock.Mock(return_value=4)
 
-        self.assertRaises(RuntimeError, p._enable_ovs_multiqueue)
+        self.assertRaises(y_exc.SSHError, p._enable_ovs_multiqueue)
 
     def test_pktgen_setup_irqmapping_ovs(self, mock_ssh):
         args = {
@@ -352,7 +352,7 @@ class PktgenTestCase(unittest.TestCase):
 
         p._setup_irqmapping_ovs(4)
 
-        mock_ssh.SSH.from_node().execute.assert_called_with(
+        mock_ssh.SSH.from_node().run.assert_called_with(
             "echo 8 | sudo tee /proc/irq/10/smp_affinity")
 
     def test_pktgen_setup_irqmapping_ovs_1q(self, mock_ssh):
@@ -367,7 +367,7 @@ class PktgenTestCase(unittest.TestCase):
 
         p._setup_irqmapping_ovs(1)
 
-        mock_ssh.SSH.from_node().execute.assert_called_with(
+        mock_ssh.SSH.from_node().run.assert_called_with(
             "echo 1 | sudo tee /proc/irq/10/smp_affinity")
 
     def test_pktgen_unsuccessful_setup_irqmapping_ovs(self, mock_ssh):
@@ -378,9 +378,9 @@ class PktgenTestCase(unittest.TestCase):
         p.server = mock_ssh.SSH.from_node()
         p.client = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
+        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
 
-        self.assertRaises(RuntimeError, p._setup_irqmapping_ovs, 4)
+        self.assertRaises(y_exc.SSHError, p._setup_irqmapping_ovs, 4)
 
     def test_pktgen_unsuccessful_setup_irqmapping_ovs_1q(self, mock_ssh):
         args = {
@@ -390,9 +390,9 @@ class PktgenTestCase(unittest.TestCase):
         p.server = mock_ssh.SSH.from_node()
         p.client = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
+        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
 
-        self.assertRaises(RuntimeError, p._setup_irqmapping_ovs, 1)
+        self.assertRaises(y_exc.SSHError, p._setup_irqmapping_ovs, 1)
 
     def test_pktgen_setup_irqmapping_sriov(self, mock_ssh):
         args = {
@@ -406,7 +406,7 @@ class PktgenTestCase(unittest.TestCase):
 
         p._setup_irqmapping_sriov(2)
 
-        mock_ssh.SSH.from_node().execute.assert_called_with(
+        mock_ssh.SSH.from_node().run.assert_called_with(
             "echo 2 | sudo tee /proc/irq/10/smp_affinity")
 
     def test_pktgen_setup_irqmapping_sriov_1q(self, mock_ssh):
@@ -421,7 +421,7 @@ class PktgenTestCase(unittest.TestCase):
 
         p._setup_irqmapping_sriov(1)
 
-        mock_ssh.SSH.from_node().execute.assert_called_with(
+        mock_ssh.SSH.from_node().run.assert_called_with(
             "echo 1 | sudo tee /proc/irq/10/smp_affinity")
 
     def test_pktgen_unsuccessful_setup_irqmapping_sriov(self, mock_ssh):
@@ -432,9 +432,9 @@ class PktgenTestCase(unittest.TestCase):
         p.server = mock_ssh.SSH.from_node()
         p.client = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
+        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
 
-        self.assertRaises(RuntimeError, p._setup_irqmapping_sriov, 2)
+        self.assertRaises(y_exc.SSHError, p._setup_irqmapping_sriov, 2)
 
     def test_pktgen_unsuccessful_setup_irqmapping_sriov_1q(self, mock_ssh):
         args = {
@@ -444,9 +444,9 @@ class PktgenTestCase(unittest.TestCase):
         p.server = mock_ssh.SSH.from_node()
         p.client = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
+        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
 
-        self.assertRaises(RuntimeError, p._setup_irqmapping_sriov, 1)
+        self.assertRaises(y_exc.SSHError, p._setup_irqmapping_sriov, 1)
 
     def test_pktgen_is_irqbalance_disabled(self, mock_ssh):
         args = {
@@ -457,10 +457,11 @@ class PktgenTestCase(unittest.TestCase):
 
         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 
-        p._is_irqbalance_disabled()
+        result = p._is_irqbalance_disabled()
+        self.assertFalse(result)
 
         mock_ssh.SSH.from_node().execute.assert_called_with(
-            "grep ENABLED /etc/default/irqbalance")
+            "grep ENABLED /etc/default/irqbalance", raise_on_error=True)
 
     def test_pktgen_unsuccessful_is_irqbalance_disabled(self, mock_ssh):
         args = {
@@ -469,9 +470,9 @@ class PktgenTestCase(unittest.TestCase):
         p = pktgen.Pktgen(args, self.ctx)
         p.server = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
+        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
 
-        self.assertRaises(RuntimeError, p._is_irqbalance_disabled)
+        self.assertRaises(y_exc.SSHError, p._is_irqbalance_disabled)
 
     def test_pktgen_disable_irqbalance(self, mock_ssh):
         args = {
@@ -481,11 +482,11 @@ class PktgenTestCase(unittest.TestCase):
         p.server = mock_ssh.SSH.from_node()
         p.client = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        mock_ssh.SSH.from_node().run.return_value = (0, '', '')
 
         p._disable_irqbalance()
 
-        mock_ssh.SSH.from_node().execute.assert_called_with(
+        mock_ssh.SSH.from_node().run.assert_called_with(
             "sudo service irqbalance disable")
 
     def test_pktgen_unsuccessful_disable_irqbalance(self, mock_ssh):
@@ -496,9 +497,9 @@ class PktgenTestCase(unittest.TestCase):
         p.server = mock_ssh.SSH.from_node()
         p.client = mock_ssh.SSH.from_node()
 
-        mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
+        mock_ssh.SSH.from_node().run.side_effect = y_exc.SSHError
 
-        self.assertRaises(RuntimeError, p._disable_irqbalance)
+        self.assertRaises(y_exc.SSHError, p._disable_irqbalance)
 
     def test_pktgen_multiqueue_setup_ovs(self, mock_ssh):
         args = {
diff --git a/yardstick/tests/unit/test_ssh.py b/yardstick/tests/unit/test_ssh.py
index 5cf1e50a0..b727e821d 100644
--- a/yardstick/tests/unit/test_ssh.py
+++ b/yardstick/tests/unit/test_ssh.py
@@ -238,6 +238,25 @@ class SSHTestCase(unittest.TestCase):
         self.assertEqual("stdout fake data", stdout)
         self.assertEqual("stderr fake data", stderr)
 
+    @mock.patch("yardstick.ssh.six.moves.StringIO")
+    def test_execute_raise_on_error_passed(self, mock_string_io):
+        mock_string_io.side_effect = stdio = [mock.Mock(), mock.Mock()]
+        stdio[0].read.return_value = "stdout fake data"
+        stdio[1].read.return_value = "stderr fake data"
+        with mock.patch.object(self.test_client, "run", return_value=0) \
+                as mock_run:
+            status, stdout, stderr = self.test_client.execute(
+                "cmd",
+                stdin="fake_stdin",
+                timeout=43,
+                raise_on_error=True)
+        mock_run.assert_called_once_with(
+            "cmd", stdin="fake_stdin", stdout=stdio[0],
+            stderr=stdio[1], timeout=43, raise_on_error=True)
+        self.assertEqual(0, status)
+        self.assertEqual("stdout fake data", stdout)
+        self.assertEqual("stderr fake data", stderr)
+
     @mock.patch("yardstick.ssh.time")
     def test_wait_timeout(self, mock_time):
         mock_time.time.side_effect = [1, 50, 150]