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

   1 # Copyright 2017 Nokia
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #   http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 import subprocess
  16 import time
  17
  18 import mock
  19 import unittest
  20
  21 from yardstick.benchmark.scenarios.networking import vsperf_dpdk
  22 from yardstick import exceptions as y_exc
  23
  24
  25 class VsperfDPDKTestCase(unittest.TestCase):
  26
  27     def setUp(self):
  28         self.ctx = {
  29             "host": {
  30                 "ip": "10.229.47.137",
  31                 "user": "ubuntu",
  32                 "password": "ubuntu",
  33             },
  34         }
  35         self.args = {
  36             'task_id': "1234-5678",
  37             'options': {
  38                 'testname': 'pvp_tput',
  39                 'traffic_type': 'rfc2544_throughput',
  40                 'frame_size': '64',
  41                 'test_params': 'TRAFFICGEN_DURATION=30;',
  42                 'trafficgen_port1': 'ens4',
  43                 'trafficgen_port2': 'ens5',
  44                 'conf_file': 'vsperf-yardstick.conf',
  45                 'setup_script': 'setup_yardstick.sh',
  46                 'moongen_helper_file': '~/moongen.py',
  47                 'moongen_host_ip': '10.5.201.151',
  48                 'moongen_port1_mac': '8c:dc:d4:ae:7c:5c',
  49                 'moongen_port2_mac': '8c:dc:d4:ae:7c:5d',
  50                 'trafficgen_port1_nw': 'test2',
  51                 'trafficgen_port2_nw': 'test3',
  52             },
  53             'sla': {
  54                 'metrics': 'throughput_rx_fps',
  55                 'throughput_rx_fps': 500000,
  56                 'action': 'monitor',
  57             }
  58         }
  59
  60         self.scenario = vsperf_dpdk.VsperfDPDK(self.args, self.ctx)
  61
  62         self._mock_ssh = mock.patch(
  63             'yardstick.benchmark.scenarios.networking.vsperf_dpdk.ssh')
  64         self.mock_ssh = self._mock_ssh.start()
  65         self._mock_subprocess_call = mock.patch.object(subprocess, 'call')
  66         self.mock_subprocess_call = self._mock_subprocess_call.start()
  67
  68         self.addCleanup(self._cleanup)
  69
  70     def _cleanup(self):
  71         self._mock_ssh.stop()
  72         self._mock_subprocess_call.stop()
  73
  74     def test_setup(self):
  75         # setup() specific mocks
  76         self.mock_subprocess_call().execute.return_value = None
  77
  78         self.scenario.setup()
  79         self.assertIsNotNone(self.scenario.client)
  80         self.assertTrue(self.scenario.setup_done)
  81
  82     def test_teardown(self):
  83         # setup() specific mocks
  84         self.mock_subprocess_call().execute.return_value = None
  85
  86         self.scenario.setup()
  87         self.assertIsNotNone(self.scenario.client)
  88         self.assertTrue(self.scenario.setup_done)
  89
  90         self.scenario.teardown()
  91         self.assertFalse(self.scenario.setup_done)
  92
  93     def test_is_dpdk_setup_no(self):
  94         # setup() specific mocks
  95         self.mock_subprocess_call().execute.return_value = None
  96
  97         self.scenario.setup()
  98         self.assertIsNotNone(self.scenario.client)
  99         self.assertTrue(self.scenario.setup_done)
 100
 101         # is_dpdk_setup() specific mocks
 102         self.mock_ssh.SSH.from_node().execute.return_value = (0, 'dummy', '')
 103
 104         result = self.scenario._is_dpdk_setup()
 105         self.assertFalse(result)
 106
 107     def test_is_dpdk_setup_yes(self):
 108         # setup() specific mocks
 109         self.mock_subprocess_call().execute.return_value = None
 110
 111         self.scenario.setup()
 112         self.assertIsNotNone(self.scenario.client)
 113         self.assertTrue(self.scenario.setup_done)
 114
 115         # is_dpdk_setup() specific mocks
 116         self.mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 117
 118         result = self.scenario._is_dpdk_setup()
 119         self.assertTrue(result)
 120
 121     @mock.patch.object(time, 'sleep')
 122     def test_dpdk_setup_first(self, *args):
 123         # setup() specific mocks
 124         self.mock_subprocess_call().execute.return_value = None
 125
 126         self.scenario.setup()
 127         self.assertIsNotNone(self.scenario.client)
 128         self.assertTrue(self.scenario.setup_done)
 129
 130         # is_dpdk_setup() specific mocks
 131         self.mock_ssh.SSH.from_node().execute.return_value = (0, 'dummy', '')
 132
 133         self.scenario.dpdk_setup()
 134         self.assertFalse(self.scenario._is_dpdk_setup())
 135         self.assertTrue(self.scenario.dpdk_setup_done)
 136
 137     @mock.patch.object(time, 'sleep')
 138     def test_dpdk_setup_next(self, *args):
 139         # setup() specific mocks
 140         self.mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 141         self.mock_subprocess_call().execute.return_value = None
 142
 143         self.scenario.setup()
 144         self.assertIsNotNone(self.scenario.client)
 145         self.assertTrue(self.scenario.setup_done)
 146
 147         self.scenario.dpdk_setup()
 148         self.assertTrue(self.scenario._is_dpdk_setup())
 149         self.assertTrue(self.scenario.dpdk_setup_done)
 150
 151     @mock.patch.object(time, 'sleep')
 152     def test_dpdk_setup_runtime_error(self, *args):
 153
 154         # setup specific mocks
 155         self.mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 156         self.mock_subprocess_call().execute.return_value = None
 157
 158         self.scenario.setup()
 159         self.assertIsNotNone(self.scenario.client)
 160         self.mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 161         self.assertTrue(self.scenario.setup_done)
 162
 163         self.assertRaises(RuntimeError, self.scenario.dpdk_setup)
 164
 165     @mock.patch.object(subprocess, 'check_output')
 166     @mock.patch('time.sleep')
 167     def test_run_ok(self, *args):
 168         # setup() specific mocks
 169         self.mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 170         self.mock_subprocess_call().execute.return_value = None
 171
 172         self.scenario.setup()
 173         self.assertIsNotNone(self.scenario.client)
 174         self.assertTrue(self.scenario.setup_done)
 175
 176         # run() specific mocks
 177         self.mock_subprocess_call().execute.return_value = None
 178         self.mock_ssh.SSH.from_node().execute.return_value = (
 179             0, 'throughput_rx_fps\r\n14797660.000\r\n', '')
 180
 181         result = {}
 182         self.scenario.run(result)
 183
 184         self.assertEqual(result['throughput_rx_fps'], '14797660.000')
 185
 186     def test_run_failed_vsperf_execution(self):
 187         # setup() specific mocks
 188         self.mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 189         self.mock_subprocess_call().execute.return_value = None
 190
 191         self.scenario.setup()
 192         self.assertIsNotNone(self.scenario.client)
 193         self.assertTrue(self.scenario.setup_done)
 194
 195         self.mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 196
 197         result = {}
 198         self.assertRaises(RuntimeError, self.scenario.run, result)
 199
 200     def test_run_falied_csv_report(self):
 201         # setup() specific mocks
 202         self.mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 203         self.mock_subprocess_call().execute.return_value = None
 204
 205         self.scenario.setup()
 206         self.assertIsNotNone(self.scenario.client)
 207         self.assertTrue(self.scenario.setup_done)
 208
 209         # run() specific mocks
 210         self.mock_subprocess_call().execute.return_value = None
 211         self.mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 212
 213         result = {}
 214         self.assertRaises(RuntimeError, self.scenario.run, result)
 215
 216     @mock.patch.object(time, 'sleep')
 217     @mock.patch.object(subprocess, 'check_output')
 218     def test_vsperf_run_sla_fail(self, *args):
 219         self.scenario.setup()
 220
 221         self.mock_ssh.SSH.from_node().execute.return_value = (
 222             0, 'throughput_rx_fps\r\n123456.000\r\n', '')
 223
 224         with self.assertRaises(y_exc.SLAValidationError) as raised:
 225             self.scenario.run({})
 226
 227         self.assertIn('VSPERF_throughput_rx_fps(123456.000000) < '
 228                       'SLA_throughput_rx_fps(500000.000000)',
 229                       str(raised.exception))
 230
 231     @mock.patch.object(time, 'sleep')
 232     @mock.patch.object(subprocess, 'check_output')
 233     def test_vsperf_run_sla_fail_metric_not_collected(self, *args):
 234         self.scenario.setup()
 235
 236         self.mock_ssh.SSH.from_node().execute.return_value = (
 237             0, 'nonexisting_metric\r\n123456.000\r\n', '')
 238
 239         with self.assertRaises(y_exc.SLAValidationError) as raised:
 240             self.scenario.run({})
 241
 242         self.assertIn('throughput_rx_fps was not collected by VSPERF',
 243                       str(raised.exception))
 244
 245     @mock.patch.object(time, 'sleep')
 246     @mock.patch.object(subprocess, 'check_output')
 247     def test_vsperf_run_sla_fail_sla_not_defined(self, *args):
 248         del self.scenario.scenario_cfg['sla']['throughput_rx_fps']
 249         self.scenario.setup()
 250
 251         self.mock_ssh.SSH.from_node().execute.return_value = (
 252             0, 'throughput_rx_fps\r\n14797660.000\r\n', '')
 253
 254         with self.assertRaises(y_exc.SLAValidationError) as raised:
 255             self.scenario.run({})
 256
 257         self.assertIn('throughput_rx_fps is not defined in SLA',
 258                       str(raised.exception))