Cleanup pktgen unit tests

* Improve test execution
* Use common functionality in setUp()
* Disable logging

JIRA: YARDSTICK-1238

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

1 files changed, 274 insertions, 490 deletions

diff --git a/yardstick/tests/unit/benchmark/scenarios/networking/test_pktgen.py b/yardstick/tests/unit/benchmark/scenarios/networking/test_pktgen.py
index 4016f5055..5761e2403 100644
--- a/yardstick/tests/unit/benchmark/scenarios/networking/test_pktgen.py
+++ b/yardstick/tests/unit/benchmark/scenarios/networking/test_pktgen.py
@@ -9,18 +9,22 @@
 
 import mock
 import unittest
+import logging
 
 from oslo_serialization import jsonutils
 
+from yardstick import ssh
 from yardstick.benchmark.scenarios.networking import pktgen
 from yardstick.common import exceptions as y_exc
 
 
-@mock.patch('yardstick.benchmark.scenarios.networking.pktgen.ssh')
+logging.disable(logging.CRITICAL)
+
+
 class PktgenTestCase(unittest.TestCase):
 
     def setUp(self):
-        self.ctx = {
+        self.context_cfg = {
             'host': {
                 'ip': '172.16.0.137',
                 'user': 'root',
@@ -33,636 +37,416 @@ class PktgenTestCase(unittest.TestCase):
                 'ipaddr': '172.16.0.138'
             }
         }
+        self.scenario_cfg = {
+            'options': {'packetsize': 60}
+        }
 
-    def test_pktgen_successful_setup(self, mock_ssh):
+        self._mock_SSH = mock.patch.object(ssh, 'SSH')
+        self.mock_SSH = self._mock_SSH.start()
 
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.setup()
+        self.mock_SSH.from_node().execute.return_value = (0, '', '')
+        self.mock_SSH.from_node().run.return_value = 0
 
-        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
-        self.assertIsNotNone(p.server)
-        self.assertIsNotNone(p.client)
-        self.assertTrue(p.setup_done)
+        self.addCleanup(self._stop_mock)
 
-    def test_pktgen_successful_iptables_setup(self, mock_ssh):
+        self.scenario = pktgen.Pktgen(self.scenario_cfg, self.context_cfg)
+        self.scenario.setup()
 
-        args = {
-            'options': {'packetsize': 60, 'number_of_ports': 10},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.number_of_ports = args['options']['number_of_ports']
+    def _stop_mock(self):
+        self._mock_SSH.stop()
+
+    def test_setup_successful(self):
+        self.assertIsNotNone(self.scenario.server)
+        self.assertIsNotNone(self.scenario.client)
+        self.assertTrue(self.scenario.setup_done)
 
-        p._iptables_setup()
+    def test_iptables_setup_successful(self):
+        self.scenario.number_of_ports = 10
+        self.scenario._iptables_setup()
 
-        mock_ssh.SSH.from_node().run.assert_called_with(
+        self.mock_SSH.from_node().run.assert_called_with(
             "sudo iptables -F; "
             "sudo iptables -A INPUT -p udp --dport 1000:%s -j DROP"
             % 1010, timeout=60)
 
-    def test_pktgen_unsuccessful_iptables_setup(self, mock_ssh):
-
-        args = {
-            'options': {'packetsize': 60, 'number_of_ports': 10},
-        }
-
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.number_of_ports = args['options']['number_of_ports']
-
-        mock_ssh.SSH.from_node().run.side_effect = y_exc.SSHError
-        self.assertRaises(y_exc.SSHError, p._iptables_setup)
+    def test_iptables_setup_unsuccessful(self):
+        self.scenario.number_of_ports = 10
+        self.mock_SSH.from_node().run.side_effect = y_exc.SSHError
 
-    def test_pktgen_successful_iptables_get_result(self, mock_ssh):
-
-        args = {
-            'options': {'packetsize': 60, 'number_of_ports': 10},
-        }
+        with self.assertRaises(y_exc.SSHError):
+            self.scenario._iptables_setup()
 
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.number_of_ports = args['options']['number_of_ports']
+    def test_iptables_get_result_successful(self):
+        self.scenario.number_of_ports = 10
+        self.mock_SSH.from_node().execute.return_value = (0, '150000', '')
 
-        mock_ssh.SSH.from_node().execute.return_value = (0, '150000', '')
-        result = p._iptables_get_result()
-        expected_result = 150000
-        self.assertEqual(result, expected_result)
+        result = self.scenario._iptables_get_result()
 
-        mock_ssh.SSH.from_node().execute.assert_called_with(
+        self.assertEqual(result, 150000)
+        self.mock_SSH.from_node().execute.assert_called_with(
             "sudo iptables -L INPUT -vnx |"
             "awk '/dpts:1000:%s/ {{printf \"%%s\", $1}}'"
             % 1010, raise_on_error=True)
 
-    def test_pktgen_unsuccessful_iptables_get_result(self, mock_ssh):
-
-        args = {
-            'options': {'packetsize': 60, 'number_of_ports': 10},
-        }
-
-        p = pktgen.Pktgen(args, self.ctx)
+    def test_iptables_get_result_unsuccessful(self):
+        self.scenario.number_of_ports = 10
+        self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
 
-        p.server = mock_ssh.SSH.from_node()
-        p.number_of_ports = args['options']['number_of_ports']
+        with self.assertRaises(y_exc.SSHError):
+            self.scenario._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_run_successful_no_sla(self):
+        self.scenario._iptables_get_result = mock.Mock(return_value=149300)
+        sample_output = jsonutils.dumps({"packets_per_second": 9753,
+                                         "errors": 0,
+                                         "packets_sent": 149776,
+                                         "packetsize": 60,
+                                         "flows": 110,
+                                         "ppm": 3179})
+        self.mock_SSH.from_node().execute.return_value = (0, sample_output, '')
 
-    def test_pktgen_successful_no_sla(self, mock_ssh):
-
-        args = {
-            'options': {'packetsize': 60, 'number_of_ports': 10},
-        }
         result = {}
+        self.scenario.run(result)
 
-        p = pktgen.Pktgen(args, self.ctx)
-
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
-
-        p._iptables_get_result = mock.Mock(return_value=149300)
-
-        sample_output = '{"packets_per_second": 9753, "errors": 0, \
-            "packets_sent": 149776, "packetsize": 60, "flows": 110, "ppm": 3179}'
-        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
-
-        p.run(result)
         expected_result = jsonutils.loads(sample_output)
         expected_result["packets_received"] = 149300
         expected_result["packetsize"] = 60
         self.assertEqual(result, expected_result)
 
-    def test_pktgen_successful_sla(self, mock_ssh):
+    def test_run_successful_sla(self):
+        self.scenario_cfg['sla'] = {'max_ppm': 10000}
+        scenario = pktgen.Pktgen(self.scenario_cfg, self.context_cfg)
+        scenario.setup()
+        scenario._iptables_get_result = mock.Mock(return_value=149300)
+        sample_output = jsonutils.dumps({"packets_per_second": 9753,
+                                         "errors": 0,
+                                         "packets_sent": 149776,
+                                         "packetsize": 60,
+                                         "flows": 110,
+                                         "ppm": 3179})
+        self.mock_SSH.from_node().execute.return_value = (0, sample_output, '')
 
-        args = {
-            'options': {'packetsize': 60, 'number_of_ports': 10},
-            'sla': {'max_ppm': 10000}
-        }
         result = {}
+        scenario.run(result)
 
-        p = pktgen.Pktgen(args, self.ctx)
-
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
-
-        p._iptables_get_result = mock.Mock(return_value=149300)
-
-        sample_output = '{"packets_per_second": 9753, "errors": 0, \
-            "packets_sent": 149776, "packetsize": 60, "flows": 110, "ppm": 3179}'
-        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
-
-        p.run(result)
         expected_result = jsonutils.loads(sample_output)
         expected_result["packets_received"] = 149300
         expected_result["packetsize"] = 60
         self.assertEqual(result, expected_result)
 
-    def test_pktgen_unsuccessful_sla(self, mock_ssh):
-
-        args = {
-            'options': {'packetsize': 60, 'number_of_ports': 10},
-            'sla': {'max_ppm': 1000}
-        }
-        result = {}
-
-        p = pktgen.Pktgen(args, self.ctx)
+    def test_run_unsuccessful_sla(self):
+        self.scenario_cfg['sla'] = {'max_ppm': 1000}
+        scenario = pktgen.Pktgen(self.scenario_cfg, self.context_cfg)
+        scenario.setup()
+        scenario._iptables_get_result = mock.Mock(return_value=149300)
+        sample_output = jsonutils.dumps({"packets_per_second": 9753,
+                                         "errors": 0,
+                                         "packets_sent": 149776,
+                                         "packetsize": 60,
+                                         "flows": 110})
+        self.mock_SSH.from_node().execute.return_value = (0, sample_output, '')
 
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
+        with self.assertRaises(y_exc.SLAValidationError):
+            scenario.run({})
 
-        p._iptables_get_result = mock.Mock(return_value=149300)
+    def test_run_ssh_error_not_caught(self):
+        self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
 
-        sample_output = '{"packets_per_second": 9753, "errors": 0, \
-            "packets_sent": 149776, "packetsize": 60, "flows": 110}'
-        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
-        self.assertRaises(y_exc.SLAValidationError, p.run, result)
+        with self.assertRaises(y_exc.SSHError):
+            self.scenario.run({})
 
-    def test_pktgen_unsuccessful_script_error(self, mock_ssh):
+    def test_get_vnic_driver_name(self):
+        self.mock_SSH.from_node().execute.return_value = (0, 'ixgbevf', '')
+        vnic_driver_name = self.scenario._get_vnic_driver_name()
 
-        args = {
-            'options': {'packetsize': 60, 'number_of_ports': 10},
-            'sla': {'max_ppm': 1000}
-        }
-        result = {}
-
-        p = pktgen.Pktgen(args, self.ctx)
-
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
-
-        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 = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-
-        mock_ssh.SSH.from_node().execute.return_value = (0, 'ixgbevf', '')
-
-        vnic_driver_name = p._get_vnic_driver_name()
         self.assertEqual(vnic_driver_name, 'ixgbevf')
 
-    def test_pktgen_unsuccessful_get_vnic_driver_name(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-
-        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
-
-        self.assertRaises(y_exc.SSHError, p._get_vnic_driver_name)
+    def test_get_vnic_driver_name_unsuccessful(self):
+        self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
 
-    def test_pktgen_get_sriov_queue_number(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-
-        mock_ssh.SSH.from_node().execute.return_value = (0, '2', '')
+        with self.assertRaises(y_exc.SSHError):
+            self.scenario._get_vnic_driver_name()
 
-        p.queue_number = p._get_sriov_queue_number()
-        self.assertEqual(p.queue_number, 2)
+    def test_get_sriov_queue_number(self):
+        self.mock_SSH.from_node().execute.return_value = (0, '2', '')
 
-    def test_pktgen_unsuccessful_get_sriov_queue_number(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
+        self.scenario.queue_number = self.scenario._get_sriov_queue_number()
+        self.assertEqual(self.scenario.queue_number, 2)
 
-        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
+    def test_get_sriov_queue_number_unsuccessful(self):
+        self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
 
-        self.assertRaises(y_exc.SSHError, p._get_sriov_queue_number)
+        with self.assertRaises(y_exc.SSHError):
+            self.scenario._get_sriov_queue_number()
 
-    def test_pktgen_get_available_queue_number(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
+    def test_get_available_queue_number(self):
+        self.mock_SSH.from_node().execute.return_value = (0, '4', '')
 
-        mock_ssh.SSH.from_node().execute.return_value = (0, '4', '')
-
-        self.assertEqual(p._get_available_queue_number(), 4)
-
-        mock_ssh.SSH.from_node().execute.assert_called_with(
+        self.assertEqual(self.scenario._get_available_queue_number(), 4)
+        self.mock_SSH.from_node().execute.assert_called_with(
             "sudo ethtool -l eth0 | grep Combined | head -1 |"
             "awk '{printf $2}'", raise_on_error=True)
 
-    def test_pktgen_unsuccessful_get_available_queue_number(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-
-        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
+    def test_get_available_queue_number_unsuccessful(self):
+        self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
 
-        self.assertRaises(y_exc.SSHError, p._get_available_queue_number)
+        with self.assertRaises(y_exc.SSHError):
+            self.scenario._get_available_queue_number()
 
-    def test_pktgen_get_usable_queue_number(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-
-        mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
+    def test_get_usable_queue_number(self):
+        self.mock_SSH.from_node().execute.return_value = (0, '1', '')
 
-        self.assertEqual(p._get_usable_queue_number(), 1)
-
-        mock_ssh.SSH.from_node().execute.assert_called_with(
+        self.assertEqual(self.scenario._get_usable_queue_number(), 1)
+        self.mock_SSH.from_node().execute.assert_called_with(
             "sudo ethtool -l eth0 | grep Combined | tail -1 |"
             "awk '{printf $2}'", raise_on_error=True)
 
-    def test_pktgen_unsuccessful_get_usable_queue_number(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
+    def test_get_usable_queue_number_unsuccessful(self):
+        self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
 
-        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
+        with self.assertRaises(y_exc.SSHError):
+            self.scenario._get_usable_queue_number()
 
-        self.assertRaises(y_exc.SSHError, p._get_usable_queue_number)
+    def test_enable_ovs_multiqueue(self):
+        self.scenario._get_usable_queue_number = mock.Mock(return_value=1)
+        self.scenario._get_available_queue_number = mock.Mock(return_value=4)
+        self.scenario.queue_number = self.scenario._enable_ovs_multiqueue()
 
-    def test_pktgen_enable_ovs_multiqueue(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
-
-        mock_ssh.SSH.from_node().execute.return_value = (0, '4', '')
+        self.assertEqual(self.scenario.queue_number, 4)
+        self.mock_SSH.from_node().run.assert_has_calls(
+            (mock.call("sudo ethtool -L eth0 combined 4"),
+             mock.call("sudo ethtool -L eth0 combined 4")))
 
-        p._get_usable_queue_number = mock.Mock(return_value=1)
-        p._get_available_queue_number = mock.Mock(return_value=4)
+    def test_enable_ovs_multiqueue_1q(self):
+        self.scenario._get_usable_queue_number = mock.Mock(return_value=1)
+        self.scenario._get_available_queue_number = mock.Mock(return_value=1)
+        self.scenario.queue_number = self.scenario._enable_ovs_multiqueue()
 
-        p.queue_number = p._enable_ovs_multiqueue()
-        self.assertEqual(p.queue_number, 4)
-
-    def test_pktgen_enable_ovs_multiqueue_1q(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
+        self.assertEqual(self.scenario.queue_number, 1)
+        self.mock_SSH.from_node().run.assert_not_called()
 
-        mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
+    def test_enable_ovs_multiqueue_unsuccessful(self):
+        self.mock_SSH.from_node().run.side_effect = y_exc.SSHError
+        self.scenario._get_usable_queue_number = mock.Mock(return_value=1)
+        self.scenario._get_available_queue_number = mock.Mock(return_value=4)
 
-        p._get_usable_queue_number = mock.Mock(return_value=1)
-        p._get_available_queue_number = mock.Mock(return_value=1)
-
-        p.queue_number = p._enable_ovs_multiqueue()
-        self.assertEqual(p.queue_number, 1)
-
-    def test_pktgen_unsuccessful_enable_ovs_multiqueue(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
+        with self.assertRaises(y_exc.SSHError):
+            self.scenario._enable_ovs_multiqueue()
 
-        mock_ssh.SSH.from_node().run.side_effect = y_exc.SSHError
+    def test_setup_irqmapping_ovs(self):
+        self.mock_SSH.from_node().execute.return_value = (0, '10', '')
+        self.scenario._setup_irqmapping_ovs(4)
 
-        p._get_usable_queue_number = mock.Mock(return_value=1)
-        p._get_available_queue_number = mock.Mock(return_value=4)
-
-        self.assertRaises(y_exc.SSHError, p._enable_ovs_multiqueue)
-
-    def test_pktgen_setup_irqmapping_ovs(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
-
-        mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
-
-        p._setup_irqmapping_ovs(4)
-
-        mock_ssh.SSH.from_node().run.assert_called_with(
+        self.mock_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):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
-
-        mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
+    def test_setup_irqmapping_ovs_1q(self):
+        self.mock_SSH.from_node().execute.return_value = (0, '10', '')
+        self.scenario._setup_irqmapping_ovs(1)
 
-        p._setup_irqmapping_ovs(1)
-
-        mock_ssh.SSH.from_node().run.assert_called_with(
+        self.mock_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):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
-
-        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
-
-        self.assertRaises(y_exc.SSHError, p._setup_irqmapping_ovs, 4)
+    def test_setup_irqmapping_ovs_unsuccessful(self):
+        self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
 
-    def test_pktgen_unsuccessful_setup_irqmapping_ovs_1q(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
-
-        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
+        with self.assertRaises(y_exc.SSHError):
+            self.scenario._setup_irqmapping_ovs(4)
 
-        self.assertRaises(y_exc.SSHError, p._setup_irqmapping_ovs, 1)
-
-    def test_pktgen_setup_irqmapping_sriov(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
+    def test_setup_irqmapping_ovs_1q_unsuccessful(self):
+        self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
 
-        mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
+        with self.assertRaises(y_exc.SSHError):
+            self.scenario._setup_irqmapping_ovs(1)
 
-        p._setup_irqmapping_sriov(2)
+    def test_setup_irqmapping_sriov(self):
+        self.mock_SSH.from_node().execute.return_value = (0, '10', '')
+        self.scenario._setup_irqmapping_sriov(2)
 
-        mock_ssh.SSH.from_node().run.assert_called_with(
+        self.mock_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):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
-
-        mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
+    def test_setup_irqmapping_sriov_1q(self):
+        self.mock_SSH.from_node().execute.return_value = (0, '10', '')
+        self.scenario._setup_irqmapping_sriov(1)
 
-        p._setup_irqmapping_sriov(1)
-
-        mock_ssh.SSH.from_node().run.assert_called_with(
+        self.mock_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):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
-
-        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
-
-        self.assertRaises(y_exc.SSHError, p._setup_irqmapping_sriov, 2)
+    def test_setup_irqmapping_sriov_unsuccessful(self):
+        self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
 
-    def test_pktgen_unsuccessful_setup_irqmapping_sriov_1q(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
+        with self.assertRaises(y_exc.SSHError):
+            self.scenario._setup_irqmapping_sriov(2)
 
-        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
+    def test_setup_irqmapping_sriov_1q_unsuccessful(self):
+        self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
 
-        self.assertRaises(y_exc.SSHError, p._setup_irqmapping_sriov, 1)
+        with self.assertRaises(y_exc.SSHError):
+            self.scenario._setup_irqmapping_sriov(1)
 
-    def test_pktgen_is_irqbalance_disabled(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
+    def test_is_irqbalance_disabled(self):
+        self.mock_SSH.from_node().execute.return_value = (0, '', '')
 
-        mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
-
-        result = p._is_irqbalance_disabled()
-        self.assertFalse(result)
-
-        mock_ssh.SSH.from_node().execute.assert_called_with(
+        self.assertFalse(self.scenario._is_irqbalance_disabled())
+        self.mock_SSH.from_node().execute.assert_called_with(
             "grep ENABLED /etc/default/irqbalance", raise_on_error=True)
 
-    def test_pktgen_unsuccessful_is_irqbalance_disabled(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-
-        mock_ssh.SSH.from_node().execute.side_effect = y_exc.SSHError
-
-        self.assertRaises(y_exc.SSHError, p._is_irqbalance_disabled)
-
-    def test_pktgen_disable_irqbalance(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
+    def test_is_irqbalance_disabled_unsuccessful(self):
+        self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
 
-        mock_ssh.SSH.from_node().run.return_value = (0, '', '')
+        with self.assertRaises(y_exc.SSHError):
+            self.scenario._is_irqbalance_disabled()
 
-        p._disable_irqbalance()
+    def test_disable_irqbalance(self):
+        self.scenario._disable_irqbalance()
 
-        mock_ssh.SSH.from_node().run.assert_called_with(
+        self.mock_SSH.from_node().run.assert_called_with(
             "sudo service irqbalance disable")
 
-    def test_pktgen_unsuccessful_disable_irqbalance(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
-
-        mock_ssh.SSH.from_node().run.side_effect = y_exc.SSHError
-
-        self.assertRaises(y_exc.SSHError, p._disable_irqbalance)
-
-    def test_pktgen_multiqueue_setup_ovs(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60, 'multiqueue': True},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
-
-        mock_ssh.SSH.from_node().execute.return_value = (0, '4', '')
+    def test_disable_irqbalance_unsuccessful(self):
+        self.mock_SSH.from_node().run.side_effect = y_exc.SSHError
 
-        p._is_irqbalance_disabled = mock.Mock(return_value=False)
-        p._get_vnic_driver_name = mock.Mock(return_value="virtio_net")
-        p._get_usable_queue_number = mock.Mock(return_value=1)
-        p._get_available_queue_number = mock.Mock(return_value=4)
+        with self.assertRaises(y_exc.SSHError):
+            self.scenario._disable_irqbalance()
 
-        p.multiqueue_setup()
+    def test_multiqueue_setup_ovs(self):
+        self.mock_SSH.from_node().execute.return_value = (0, '4', '')
+        self.scenario._is_irqbalance_disabled = mock.Mock(return_value=False)
+        self.scenario._get_vnic_driver_name = mock.Mock(
+            return_value="virtio_net")
+        self.scenario._get_usable_queue_number = mock.Mock(return_value=1)
+        self.scenario._get_available_queue_number = mock.Mock(return_value=4)
 
-        self.assertEqual(p.queue_number, 4)
+        self.scenario.multiqueue_setup()
 
-    def test_pktgen_multiqueue_setup_ovs_1q(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60, 'multiqueue': True},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
+        self.assertEqual(self.scenario.queue_number, 4)
+        self.assertTrue(self.scenario.multiqueue_setup_done)
 
-        mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
+    def test_multiqueue_setup_ovs_1q(self):
+        self.mock_SSH.from_node().execute.return_value = (0, '1', '')
+        self.scenario._is_irqbalance_disabled = mock.Mock(return_value=False)
+        self.scenario._get_vnic_driver_name = mock.Mock(
+            return_value="virtio_net")
+        self.scenario._get_usable_queue_number = mock.Mock(return_value=1)
+        self.scenario._get_available_queue_number = mock.Mock(return_value=1)
 
-        p._is_irqbalance_disabled = mock.Mock(return_value=False)
-        p._get_vnic_driver_name = mock.Mock(return_value="virtio_net")
-        p._get_usable_queue_number = mock.Mock(return_value=1)
-        p._get_available_queue_number = mock.Mock(return_value=1)
+        self.scenario.multiqueue_setup()
 
-        p.multiqueue_setup()
+        self.assertEqual(self.scenario.queue_number, 1)
+        self.assertTrue(self.scenario.multiqueue_setup_done)
 
-        self.assertEqual(p.queue_number, 1)
+    def test_multiqueue_setup_sriov(self):
+        self.mock_SSH.from_node().execute.return_value = (0, '2', '')
+        self.scenario._is_irqbalance_disabled = mock.Mock(return_value=False)
+        self.scenario._get_vnic_driver_name = mock.Mock(return_value="ixgbevf")
 
-    def test_pktgen_multiqueue_setup_sriov(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60, 'multiqueue': True},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
+        self.scenario.multiqueue_setup()
 
-        mock_ssh.SSH.from_node().execute.return_value = (0, '2', '')
+        self.assertEqual(self.scenario.queue_number, 2)
+        self.assertTrue(self.scenario.multiqueue_setup_done)
 
-        p._is_irqbalance_disabled = mock.Mock(return_value=False)
-        p._get_vnic_driver_name = mock.Mock(return_value="ixgbevf")
+    def test_multiqueue_setup_sriov_1q(self):
+        self.mock_SSH.from_node().execute.return_value = (0, '1', '')
+        self.scenario._is_irqbalance_disabled = mock.Mock(return_value=False)
+        self.scenario._get_vnic_driver_name = mock.Mock(return_value="ixgbevf")
 
-        p.multiqueue_setup()
+        self.scenario.multiqueue_setup()
 
-        self.assertEqual(p.queue_number, 2)
+        self.assertEqual(self.scenario.queue_number, 1)
+        self.assertTrue(self.scenario.multiqueue_setup_done)
 
-    def test_pktgen_multiqueue_setup_sriov_1q(self, mock_ssh):
-        args = {
-            'options': {'packetsize': 60, 'multiqueue': True},
-        }
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
-
-        mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
-
-        p._is_irqbalance_disabled = mock.Mock(return_value=False)
-        p._get_vnic_driver_name = mock.Mock(return_value="ixgbevf")
-
-        p.multiqueue_setup()
-
-        self.assertEqual(p.queue_number, 1)
-
-    def test_pktgen_run_with_setup_done(self, mock_ssh):
-        args = {
+    def test_run_with_setup_done(self):
+        scenario_cfg = {
             'options': {
                 'packetsize': 60,
                 'number_of_ports': 10,
                 'duration': 20,
                 'multiqueue': True},
             'sla': {
-                'max_ppm': 1}}
-        result = {}
-        p = pktgen.Pktgen(args, self.ctx)
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
+                'max_ppm': 1}
+        }
+        scenario = pktgen.Pktgen(scenario_cfg, self.context_cfg)
+        scenario.server = self.mock_SSH.from_node()
+        scenario.client = self.mock_SSH.from_node()
+        scenario.setup_done = True
+        scenario.multiqueue_setup_done = True
+        scenario._iptables_get_result = mock.Mock(return_value=149300)
+
+        sample_output = jsonutils.dumps({"packets_per_second": 9753,
+                                         "errors": 0,
+                                         "packets_sent": 149300,
+                                         "flows": 110,
+                                         "ppm": 0})
+        self.mock_SSH.from_node().execute.return_value = (0, sample_output, '')
 
-        p.setup_done = True
-        p.multiqueue_setup_done = True
-
-        mock_iptables_result = mock.Mock()
-        mock_iptables_result.return_value = 149300
-        p._iptables_get_result = mock_iptables_result
-
-        sample_output = '{"packets_per_second": 9753, "errors": 0, \
-            "packets_sent": 149300, "flows": 110, "ppm": 0}'
-        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
+        result = {}
+        scenario.run(result)
 
-        p.run(result)
         expected_result = jsonutils.loads(sample_output)
         expected_result["packets_received"] = 149300
         expected_result["packetsize"] = 60
         self.assertEqual(result, expected_result)
 
-    def test_pktgen_run_with_ovs_multiqueque(self, mock_ssh):
-        args = {
+    def test_run_with_ovs_multiqueque(self):
+        scenario_cfg = {
             'options': {
                 'packetsize': 60,
                 'number_of_ports': 10,
                 'duration': 20,
                 'multiqueue': True},
-            'sla': {
-                'max_ppm': 1}}
-        result = {}
-
-        p = pktgen.Pktgen(args, self.ctx)
-
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
-
-        p._get_vnic_driver_name = mock.Mock(return_value="virtio_net")
-        p._get_usable_queue_number = mock.Mock(return_value=1)
-        p._get_available_queue_number = mock.Mock(return_value=4)
-        p._enable_ovs_multiqueue = mock.Mock(return_value=4)
-        p._setup_irqmapping_ovs = mock.Mock()
-        p._iptables_get_result = mock.Mock(return_value=149300)
+            'sla': {'max_ppm': 1}
+        }
+        scenario = pktgen.Pktgen(scenario_cfg, self.context_cfg)
+        scenario.setup()
+        scenario._get_vnic_driver_name = mock.Mock(return_value="virtio_net")
+        scenario._get_usable_queue_number = mock.Mock(return_value=1)
+        scenario._get_available_queue_number = mock.Mock(return_value=4)
+        scenario._enable_ovs_multiqueue = mock.Mock(return_value=4)
+        scenario._setup_irqmapping_ovs = mock.Mock()
+        scenario._iptables_get_result = mock.Mock(return_value=149300)
+
+        sample_output = jsonutils.dumps({"packets_per_second": 9753,
+                                         "errors": 0,
+                                         "packets_sent": 149300,
+                                         "flows": 110,
+                                         "ppm": 0})
+        self.mock_SSH.from_node().execute.return_value = (0, sample_output, '')
 
-        sample_output = '{"packets_per_second": 9753, "errors": 0, \
-            "packets_sent": 149300, "flows": 110, "ppm": 0}'
-        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
+        result = {}
+        scenario.run(result)
 
-        p.run(result)
         expected_result = jsonutils.loads(sample_output)
         expected_result["packets_received"] = 149300
         expected_result["packetsize"] = 60
         self.assertEqual(result, expected_result)
 
-    def test_pktgen_run_with_sriov_multiqueque(self, mock_ssh):
-        args = {
+    def test_run_with_sriov_multiqueque(self):
+        scenario_cfg = {
             'options': {
                 'packetsize': 60,
                 'number_of_ports': 10,
                 'duration': 20,
                 'multiqueue': True},
-            'sla': {
-                'max_ppm': 1}}
-        result = {}
-
-        p = pktgen.Pktgen(args, self.ctx)
+            'sla': {'max_ppm': 1}
+        }
+        scenario = pktgen.Pktgen(scenario_cfg, self.context_cfg)
+        scenario.setup()
+        scenario._get_vnic_driver_name = mock.Mock(return_value="ixgbevf")
+        scenario._get_sriov_queue_number = mock.Mock(return_value=2)
+        scenario._setup_irqmapping_sriov = mock.Mock()
+        scenario._iptables_get_result = mock.Mock(return_value=149300)
+
+        sample_output = jsonutils.dumps({"packets_per_second": 9753,
+                                         "errors": 0,
+                                         "packets_sent": 149300,
+                                         "flows": 110,
+                                         "ppm": 0})
+        self.mock_SSH.from_node().execute.return_value = (0, sample_output, '')
 
-        p.server = mock_ssh.SSH.from_node()
-        p.client = mock_ssh.SSH.from_node()
-
-        p._get_vnic_driver_name = mock.Mock(return_value="ixgbevf")
-        p._get_sriov_queue_number = mock.Mock(return_value=2)
-        p._setup_irqmapping_sriov = mock.Mock()
-        p._iptables_get_result = mock.Mock(return_value=149300)
-
-        sample_output = '{"packets_per_second": 9753, "errors": 0, \
-            "packets_sent": 149300, "flows": 110, "ppm": 0}'
-        mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
+        result = {}
+        scenario.run(result)
 
-        p.run(result)
         expected_result = jsonutils.loads(sample_output)
         expected_result["packets_received"] = 149300
         expected_result["packetsize"] = 60