Cleanup pktgen_dpdk unit tests

* Improve test execution
* Use common functionality in setUp()
* Disable logging
* Remove tests that test common/utils code. These tests are moved to
  common/utils's unit tests in a follow-up patch.

JIRA: YARDSTICK-1239

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

diff --git a/yardstick/tests/unit/benchmark/scenarios/networking/test_pktgen_dpdk.py b/yardstick/tests/unit/benchmark/scenarios/networking/test_pktgen_dpdk.py
index bcd4178..70cd8ad 100644 (file)
--- a/yardstick/tests/unit/benchmark/scenarios/networking/test_pktgen_dpdk.py
+++ b/yardstick/tests/unit/benchmark/scenarios/networking/test_pktgen_dpdk.py
@@ -9,16 +9,22 @@
 
 import mock
 import unittest
+import time
+import logging
 
 import yardstick.common.utils as utils
+from yardstick import ssh
 from yardstick.benchmark.scenarios.networking import pktgen_dpdk
 from yardstick.common import exceptions as y_exc
 
 
+logging.disable(logging.CRITICAL)
+
+
 class PktgenDPDKLatencyTestCase(unittest.TestCase):
 
     def setUp(self):
-        self.ctx = {
+        self.context_cfg = {
             'host': {
                 'ip': '172.16.0.137',
                 'user': 'root',
@@ -31,165 +37,100 @@ class PktgenDPDKLatencyTestCase(unittest.TestCase):
                 'ipaddr': '172.16.0.138'
             }
         }
-
-        self._mock_ssh = mock.patch(
-            'yardstick.benchmark.scenarios.networking.pktgen_dpdk.ssh')
-        self.mock_ssh = self._mock_ssh.start()
-        self._mock_time = mock.patch(
-            'yardstick.benchmark.scenarios.networking.pktgen_dpdk.time')
-        self.mock_time = self._mock_time.start()
-
-        self.addCleanup(self._stop_mock)
-
-    def _stop_mock(self):
-        self._mock_ssh.stop()
-        self._mock_time.stop()
-
-    def test_pktgen_dpdk_successful_setup(self):
-
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
-        p.setup()
-
-        self.mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
-        self.assertIsNotNone(p.server)
-        self.assertIsNotNone(p.client)
-        self.assertTrue(p.setup_done)
-
-    def test_pktgen_dpdk_successful_get_port_ip(self):
-
-        args = {
-            'options': {'packetsize': 60},
+        self.scenario_cfg = {
+            'options': {'packetsize': 60}
         }
-        p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
-        p.server = self.mock_ssh.SSH.from_node()
-
-        self.mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 
-        utils.get_port_ip(p.server, "eth1")
+        self._mock_SSH = mock.patch.object(ssh, 'SSH')
+        self.mock_SSH = self._mock_SSH.start()
 
-        self.mock_ssh.SSH.from_node().execute.assert_called_with(
-            "ifconfig eth1 |grep 'inet addr' |awk '{print $2}' |cut -d ':' -f2 ")
-
-    def test_pktgen_dpdk_unsuccessful_get_port_ip(self):
-
-        args = {
-            'options': {'packetsize': 60},
-        }
+        self._mock_time_sleep = mock.patch.object(time, 'sleep')
+        self.mock_time_sleep = self._mock_time_sleep.start()
 
-        p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
-        p.server = self.mock_ssh.SSH.from_node()
+        self._mock_utils_get_port_ip = mock.patch.object(utils, 'get_port_ip')
+        self.mock_utils_get_port_ip = self._mock_utils_get_port_ip.start()
 
-        self.mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
-        self.assertRaises(RuntimeError, utils.get_port_ip, p.server, "eth1")
+        self._mock_utils_get_port_mac = mock.patch.object(utils,
+                                                          'get_port_mac')
+        self.mock_utils_get_port_mac = self._mock_utils_get_port_mac.start()
 
-    def test_pktgen_dpdk_successful_get_port_mac(self):
+        self.mock_SSH.from_node().execute.return_value = (0, '', '')
 
-        args = {
-            'options': {'packetsize': 60},
-        }
-        p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
-        p.server = self.mock_ssh.SSH.from_node()
+        self.addCleanup(self._stop_mock)
 
-        self.mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
+        self.scenario = pktgen_dpdk.PktgenDPDKLatency(self.scenario_cfg,
+                                                      self.context_cfg)
+        self.scenario.server = self.mock_SSH.from_node()
+        self.scenario.client = self.mock_SSH.from_node()
 
-        utils.get_port_mac(p.server, "eth1")
+    def _stop_mock(self):
+        self._mock_SSH.stop()
+        self._mock_time_sleep.stop()
+        self._mock_utils_get_port_ip.stop()
+        self._mock_utils_get_port_mac.stop()
 
-        self.mock_ssh.SSH.from_node().execute.assert_called_with(
-            "ifconfig |grep HWaddr |grep eth1 |awk '{print $5}' ")
+    def test_setup(self):
+        scenario = pktgen_dpdk.PktgenDPDKLatency(self.scenario_cfg,
+                                                 self.context_cfg)
+        scenario.setup()
 
-    def test_pktgen_dpdk_unsuccessful_get_port_mac(self):
+        self.assertIsNotNone(scenario.server)
+        self.assertIsNotNone(scenario.client)
+        self.assertTrue(scenario.setup_done)
 
-        args = {
-            'options': {'packetsize': 60},
-        }
+    def test_run_get_port_ip_command(self):
+        self.scenario.run({})
 
-        p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
-        p.server = self.mock_ssh.SSH.from_node()
+        self.mock_utils_get_port_ip.assert_has_calls(
+            [mock.call(self.scenario.server, 'ens4'),
+             mock.call(self.scenario.server, 'ens5')])
 
-        self.mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
-        self.assertRaises(RuntimeError, utils.get_port_mac, p.server, "eth1")
+    def test_get_port_mac_command(self):
+        self.scenario.run({})
 
-    def test_pktgen_dpdk_successful_no_sla(self):
-
-        args = {
-            'options': {'packetsize': 60},
-        }
-
-        result = {}
-        p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
+        self.mock_utils_get_port_mac.assert_has_calls(
+            [mock.call(self.scenario.server, 'ens5'),
+             mock.call(self.scenario.server, 'ens4'),
+             mock.call(self.scenario.server, 'ens5')])
 
+    def test_run_no_sla(self):
         sample_output = '100\n110\n112\n130\n149\n150\n90\n150\n200\n162\n'
-        self.mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
+        self.mock_SSH.from_node().execute.return_value = (0, sample_output, '')
 
-        p.run(result)
+        result = {}
+        self.scenario.run(result)
         # with python 3 we get float, might be due python division changes
         # AssertionError: {'avg_latency': 132.33333333333334} != {
         # 'avg_latency': 132}
         delta = result['avg_latency'] - 132
         self.assertLessEqual(delta, 1)
 
-    def test_pktgen_dpdk_successful_sla(self):
-
-        args = {
-            'options': {'packetsize': 60},
-            'sla': {'max_latency': 100}
-        }
-        result = {}
-
-        p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
+    def test_run_sla(self):
+        self.scenario_cfg['sla'] = {'max_latency': 100}
+        scenario = pktgen_dpdk.PktgenDPDKLatency(self.scenario_cfg,
+                                                 self.context_cfg)
 
         sample_output = '100\n100\n100\n100\n100\n100\n100\n100\n100\n100\n'
-        self.mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
-
-        p.run(result)
-
-        self.assertEqual(result, {"avg_latency": 100})
+        self.mock_SSH.from_node().execute.return_value = (0, sample_output, '')
 
-    def test_pktgen_dpdk_unsuccessful_sla(self):
-
-        args = {
-            'options': {'packetsize': 60},
-            'sla': {'max_latency': 100}
-        }
         result = {}
+        scenario.run(result)
 
-        p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
+        self.assertEqual(result, {"avg_latency": 100})
 
-        p.server = self.mock_ssh.SSH.from_node()
-        p.client = self.mock_ssh.SSH.from_node()
+    def test_run_sla_error(self):
+        self.scenario_cfg['sla'] = {'max_latency': 100}
+        scenario = pktgen_dpdk.PktgenDPDKLatency(self.scenario_cfg,
+                                                 self.context_cfg)
 
         sample_output = '100\n110\n112\n130\n149\n150\n90\n150\n200\n162\n'
-        self.mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
-        self.assertRaises(y_exc.SLAValidationError, p.run, result)
+        self.mock_SSH.from_node().execute.return_value = (0, sample_output, '')
 
-    def test_pktgen_dpdk_run_unsuccessful_get_port_mac(self):
-
-        args = {
-            'options': {'packetsize': 60},
-            'sla': {'max_latency': 100}
-        }
-        result = {}
-
-        p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
-
-        self.mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
-        self.assertRaises(RuntimeError, p.run, result)
-
-    def test_pktgen_dpdk_run_unsuccessful_script_error(self):
-        args = {
-            'options': {'packetsize': 60}
-        }
+        with self.assertRaises(y_exc.SLAValidationError):
+            scenario.run({})
 
-        p = pktgen_dpdk.PktgenDPDKLatency(args, self.ctx)
+    def test_run_last_command_raise_on_error(self):
+        self.mock_SSH.from_node().execute.side_effect = y_exc.SSHError
 
-        self.mock_ssh.SSH.from_node().execute.side_effect = ((0, '', ''),
-                                                             (0, '', ''),
-                                                             (0, '', ''),
-                                                             (0, '', ''),
-                                                             (0, '', ''),
-                                                             y_exc.SSHError)
-        self.assertRaises(y_exc.SSHError, p.run, {})
-        self.assertEqual(self.mock_ssh.SSH.from_node().execute.call_count, 6)
+        with self.assertRaises(y_exc.SSHError):
+            self.scenario.run({})