yardstick/tests/unit/benchmark/scenarios/networking/test_moongen_testpmd.py

   1 #!/usr/bin/env python
   2
   3 # Copyright 2017 Nokia
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #   http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 # Unittest for yardstick.benchmark.scenarios.networking.MoongenTestPMD
  18
  19 from __future__ import absolute_import
  20 try:
  21     from unittest import mock
  22 except ImportError:
  23     import mock
  24 import unittest
  25
  26 from yardstick.benchmark.scenarios.networking import moongen_testpmd
  27
  28
  29 @mock.patch('yardstick.benchmark.scenarios.networking.moongen_testpmd.subprocess')
  30 class MoongenTestPMDTestCase(unittest.TestCase):
  31
  32     def setUp(self):
  33         self.ctx = {
  34             "host": {
  35                 "ip": "10.229.47.137",
  36                 "user": "ubuntu",
  37                 "password": "ubuntu",
  38             },
  39         }
  40         self.TestPMDargs = {
  41             'task_id': "1234-5678",
  42             'options': {
  43                 'multistream': 1,
  44                 'frame_size': 1024,
  45                 'testpmd_queue': 2,
  46                 'trafficgen_port1': 'ens5',
  47                 'trafficgen_port2': 'ens6',
  48                 'moongen_host_user': 'root',
  49                 'moongen_host_passwd': 'root',
  50                 'moongen_host_ip': '10.5.201.151',
  51                 'moongen_dir': '/home/lua-trafficgen',
  52                 'moongen_runBidirec': 'true',
  53                 'Package_Loss': 0,
  54                 'SearchRuntime': 60,
  55                 'moongen_port1_mac': '88:cf:98:2f:4d:ed',
  56                 'moongen_port2_mac': '88:cf:98:2f:4d:ee',
  57                 'forward_type': 'testpmd',
  58             },
  59             'sla': {
  60                 'metrics': 'throughput_rx_mpps',
  61                 'throughput_rx_mpps': 0.5,
  62                 'action': 'monitor',
  63             }
  64         }
  65         self.L2fwdargs = {
  66             'task_id': "1234-5678",
  67             'options': {
  68                 'multistream': 1,
  69                 'frame_size': 1024,
  70                 'testpmd_queue': 2,
  71                 'trafficgen_port1': 'ens5',
  72                 'trafficgen_port2': 'ens6',
  73                 'moongen_host_user': 'root',
  74                 'moongen_host_passwd': 'root',
  75                 'moongen_host_ip': '10.5.201.151',
  76                 'moongen_dir': '/home/lua-trafficgen',
  77                 'moongen_runBidirec': 'true',
  78                 'Package_Loss': 0,
  79                 'SearchRuntime': 60,
  80                 'moongen_port1_mac': '88:cf:98:2f:4d:ed',
  81                 'moongen_port2_mac': '88:cf:98:2f:4d:ee',
  82                 'forward_type': 'l2fwd',
  83             },
  84             'sla': {
  85                 'metrics': 'throughput_rx_mpps',
  86                 'throughput_rx_mpps': 0.5,
  87                 'action': 'monitor',
  88             }
  89         }
  90
  91         self._mock_ssh = mock.patch(
  92             'yardstick.benchmark.scenarios.networking.moongen_testpmd.ssh')
  93         self.mock_ssh = self._mock_ssh.start()
  94
  95         self.addCleanup(self._cleanup)
  96
  97     def _cleanup(self):
  98         self._mock_ssh.stop()
  99
 100     def test_MoongenTestPMD_setup(self, mock_subprocess):
 101         p = moongen_testpmd.MoongenTestPMD(self.TestPMDargs, self.ctx)
 102
 103         # setup() specific mocks
 104         mock_subprocess.call().execute.return_value = None
 105
 106         p.setup()
 107         self.assertIsNotNone(p.client)
 108         self.assertTrue(p.setup_done)
 109
 110     def test_MoongenTestPMD_teardown(self, mock_subprocess):
 111         p = moongen_testpmd.MoongenTestPMD(self.TestPMDargs, self.ctx)
 112
 113         # setup() specific mocks
 114         mock_subprocess.call().execute.return_value = None
 115
 116         p.setup()
 117         self.assertIsNotNone(p.client)
 118         self.assertTrue(p.setup_done)
 119
 120         p.teardown()
 121         self.assertFalse(p.setup_done)
 122
 123     def test_MoongenTestPMD_l2fwd_is_forward_setup_no(self, mock_subprocess):
 124         p = moongen_testpmd.MoongenTestPMD(self.L2fwdargs, self.ctx)
 125
 126         # setup() specific mocks
 127         mock_subprocess.call().execute.return_value = None
 128
 129         p.setup()
 130         self.assertIsNotNone(p.client)
 131         self.assertTrue(p.setup_done)
 132
 133         # is_dpdk_setup() specific mocks
 134         self.mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 135
 136         result = p._is_forward_setup()
 137         self.assertFalse(result)
 138
 139     def test_MoongenTestPMD_l2fwd_is_forward_setup_yes(self, mock_subprocess):
 140         p = moongen_testpmd.MoongenTestPMD(self.L2fwdargs, self.ctx)
 141
 142         # setup() specific mocks
 143         mock_subprocess.call().execute.return_value = None
 144
 145         p.setup()
 146         self.assertIsNotNone(p.client)
 147         self.assertTrue(p.setup_done)
 148
 149         # is_dpdk_setup() specific mocks
 150         self.mock_ssh.SSH.from_node().execute.return_value = (0, 'dummy', '')
 151
 152         result = p._is_forward_setup()
 153         self.assertTrue(result)
 154
 155     def test_MoongenTestPMD_testpmd_is_forward_setup_no(self, mock_subprocess):
 156         p = moongen_testpmd.MoongenTestPMD(self.TestPMDargs, self.ctx)
 157
 158         # setup() specific mocks
 159         mock_subprocess.call().execute.return_value = None
 160
 161         p.setup()
 162         self.assertIsNotNone(p.client)
 163         self.assertTrue(p.setup_done)
 164
 165         # is_dpdk_setup() specific mocks
 166         self.mock_ssh.SSH.from_node().execute.return_value = (0, 'dummy', '')
 167
 168         result = p._is_forward_setup()
 169         self.assertFalse(result)
 170
 171     def test_MoongenTestPMD_testpmd_is_forward_setup_yes(self, mock_subprocess):
 172         p = moongen_testpmd.MoongenTestPMD(self.TestPMDargs, self.ctx)
 173
 174         # setup() specific mocks
 175         mock_subprocess.call().execute.return_value = None
 176
 177         p.setup()
 178         self.assertIsNotNone(p.client)
 179         self.assertTrue(p.setup_done)
 180
 181         # is_dpdk_setup() specific mocks
 182         self.mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 183
 184         result = p._is_forward_setup()
 185         self.assertTrue(result)
 186
 187     @mock.patch('time.sleep')
 188     def test_MoongenTestPMD_testpmd_forward_setup_first(self, _, mock_subprocess):
 189         p = moongen_testpmd.MoongenTestPMD(self.TestPMDargs, self.ctx)
 190
 191         # setup() specific mocks
 192         mock_subprocess.call().execute.return_value = None
 193
 194         p.setup()
 195         self.assertIsNotNone(p.client)
 196         self.assertTrue(p.setup_done)
 197
 198         # is_dpdk_setup() specific mocks
 199         self.mock_ssh.SSH.from_node().execute.return_value = (0, 'dummy', '')
 200
 201         p.forward_setup()
 202         self.assertFalse(p._is_forward_setup())
 203         self.assertTrue(p.forward_setup_done)
 204
 205     @mock.patch('time.sleep')
 206     def test_MoongenTestPMD_testpmd_dpdk_setup_next(self, _, mock_subprocess):
 207         p = moongen_testpmd.MoongenTestPMD(self.TestPMDargs, self.ctx)
 208
 209         # setup() specific mocks
 210         self.mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 211         mock_subprocess.call().execute.return_value = None
 212
 213         p.setup()
 214         self.assertIsNotNone(p.client)
 215         self.assertTrue(p.setup_done)
 216
 217         p.forward_setup()
 218         self.assertTrue(p._is_forward_setup())
 219         self.assertTrue(p.forward_setup_done)
 220
 221     @mock.patch('time.sleep')
 222     def test_MoongenTestPMD_l2fwd_forward_setup_first(self, _, mock_subprocess):
 223         p = moongen_testpmd.MoongenTestPMD(self.L2fwdargs, self.ctx)
 224
 225         # setup() specific mocks
 226         mock_subprocess.call().execute.return_value = None
 227
 228         p.setup()
 229         self.assertIsNotNone(p.client)
 230         self.assertTrue(p.setup_done)
 231
 232         # is_dpdk_setup() specific mocks
 233         self.mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 234
 235         p.forward_setup()
 236         self.assertFalse(p._is_forward_setup())
 237         self.assertTrue(p.forward_setup_done)
 238
 239     @mock.patch('time.sleep')
 240     def test_MoongenTestPMD_l2fwd_dpdk_setup_next(self, _, mock_subprocess):
 241         p = moongen_testpmd.MoongenTestPMD(self.L2fwdargs, self.ctx)
 242
 243         # setup() specific mocks
 244         self.mock_ssh.SSH.from_node().execute.return_value = (0, 'dummy', '')
 245         mock_subprocess.call().execute.return_value = None
 246
 247         p.setup()
 248         self.assertIsNotNone(p.client)
 249         self.assertTrue(p.setup_done)
 250
 251         p.forward_setup()
 252         self.assertTrue(p._is_forward_setup())
 253         self.assertTrue(p.forward_setup_done)
 254
 255     def test_moongen_testpmd_generate_config_file(self, mock_subprocess):
 256         p = moongen_testpmd.MoongenTestPMD(self.TestPMDargs, self.ctx)
 257
 258         # setup() specific mocks
 259         mock_subprocess.call().execute.return_value = None
 260
 261         p.generate_config_file(frame_size=1, multistream=1,
 262                                runBidirec="True", tg_port1_vlan=1,
 263                                tg_port2_vlan=2, SearchRuntime=1,
 264                                Package_Loss=0)
 265         self.assertTrue(p.CONFIG_FILE)
 266
 267     def test_moongen_testpmd_result_to_data_match(self, mock_subprocess):
 268         p = moongen_testpmd.MoongenTestPMD(self.TestPMDargs, self.ctx)
 269
 270         mock_subprocess.call().execute.return_value = None
 271         result = ("[REPORT]Device 1->0: Tx frames: 420161490 Rx Frames: 420161490"
 272                   " frame loss: 0, 0.000000% Rx Mpps: 7.002708\n[REPORT]      "
 273                   "total: Tx frames: 840321216 Rx Frames: 840321216 frame loss: "
 274                   "0, 0.000000% Tx Mpps: 14.005388 Rx Mpps: 14.005388\n'")
 275         p.result_to_data(result=result)
 276         self.assertTrue(p.TO_DATA)
 277
 278     def test_moongen_testpmd_result_to_data_not_match(self, mock_subprocess):
 279         p = moongen_testpmd.MoongenTestPMD(self.TestPMDargs, self.ctx)
 280
 281         mock_subprocess.call().execute.return_value = None
 282         result = ("")
 283         p.result_to_data(result=result)
 284         self.assertTrue(p.TO_DATA)
 285
 286     @mock.patch('time.sleep')
 287     def test_moongen_testpmd_run_ok(self, _, mock_subprocess):
 288         p = moongen_testpmd.MoongenTestPMD(self.TestPMDargs, self.ctx)
 289         p.setup_done = True
 290         p.forward_setup_done = True
 291         p.setup()
 292
 293         # run() specific mocks
 294         p.server = self.mock_ssh.SSH.from_node()
 295         mock_subprocess.call().execute.return_value = None
 296         mock_subprocess.call().execute.return_value = None
 297         result = ("[REPORT]Device 1->0: Tx frames: 420161490 Rx Frames: 420161490"
 298                   " frame loss: 0, 0.000000% Rx Mpps: 7.002708\n[REPORT]      "
 299                   "total: Tx frames: 840321216 Rx Frames: 840321216 frame loss: "
 300                   "0, 0.000000% Tx Mpps: 14.005388 Rx Mpps: 14.005388\n'")
 301         self.mock_ssh.SSH.from_node().execute.return_value = (
 302             0, result, '')
 303
 304         test_result = {}
 305         p.run(test_result)
 306
 307         self.assertEqual(test_result['rx_mpps'], 14.005388)
 308
 309     def test_moongen_testpmd_run_falied_vsperf_execution(self, mock_subprocess):
 310         p = moongen_testpmd.MoongenTestPMD(self.TestPMDargs, self.ctx)
 311
 312         # setup() specific mocks
 313         self.mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 314         mock_subprocess.call().execute.return_value = None
 315
 316         p.setup()
 317         self.assertIsNotNone(p.client)
 318         self.assertTrue(p.setup_done)
 319
 320         # run() specific mocks
 321         mock_subprocess.call().execute.return_value = None
 322         mock_subprocess.call().execute.return_value = None
 323         self.mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 324
 325         result = {}
 326         self.assertRaises(RuntimeError, p.run, result)
 327
 328     def test_moongen_testpmd_run_falied_csv_report(self, mock_subprocess):
 329         p = moongen_testpmd.MoongenTestPMD(self.TestPMDargs, self.ctx)
 330
 331         # setup() specific mocks
 332         self.mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 333         mock_subprocess.call().execute.return_value = None
 334
 335         p.setup()
 336         self.assertIsNotNone(p.client)
 337         self.assertTrue(p.setup_done)
 338
 339         # run() specific mocks
 340         mock_subprocess.call().execute.return_value = None
 341         mock_subprocess.call().execute.return_value = None
 342         self.mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 343         self.mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 344
 345         result = {}
 346         self.assertRaises(RuntimeError, p.run, result)
 347
 348 def main():
 349     unittest.main()
 350
 351
 352 if __name__ == '__main__':
 353     main()