test/test_nfvbench.py

   1 #!/usr/bin/env python
   2 # Copyright 2016 Cisco Systems, Inc.  All rights reserved.
   3 #
   4 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
   5 #    not use this file except in compliance with the License. You may obtain
   6 #    a copy of the License at
   7 #
   8 #         http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 #    Unless required by applicable law or agreed to in writing, software
  11 #    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  12 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  13 #    License for the specific language governing permissions and limitations
  14 #    under the License.
  15 #
  16 from mock import patch
  17 import pytest
  18
  19 from .mock_trex import no_op
  20
  21 import json
  22 import logging
  23 import sys
  24 from attrdict import AttrDict
  25 from nfvbench.config import config_loads
  26 from nfvbench.credentials import Credentials
  27 from nfvbench.fluentd import FluentLogHandler
  28 import nfvbench.log
  29 import nfvbench.nfvbench
  30 from nfvbench.traffic_client import Device
  31 from nfvbench.traffic_client import GeneratorConfig
  32 from nfvbench.traffic_client import IpBlock
  33 from nfvbench.traffic_client import TrafficClient
  34 import nfvbench.traffic_gen.traffic_utils as traffic_utils
  35
  36
  37 # just to get rid of the unused function warning
  38 no_op()
  39
  40 def setup_module(module):
  41     """Enable log."""
  42     nfvbench.log.setup(mute_stdout=True)
  43
  44 # =========================================================================
  45 # Traffic client tests
  46 # =========================================================================
  47
  48 def test_parse_rate_str():
  49     parse_rate_str = traffic_utils.parse_rate_str
  50     try:
  51         assert parse_rate_str('100%') == {'rate_percent': '100.0'}
  52         assert parse_rate_str('37.5%') == {'rate_percent': '37.5'}
  53         assert parse_rate_str('100%') == {'rate_percent': '100.0'}
  54         assert parse_rate_str('60pps') == {'rate_pps': '60'}
  55         assert parse_rate_str('60kpps') == {'rate_pps': '60000'}
  56         assert parse_rate_str('6Mpps') == {'rate_pps': '6000000'}
  57         assert parse_rate_str('6gpps') == {'rate_pps': '6000000000'}
  58         assert parse_rate_str('80bps') == {'rate_bps': '80'}
  59         assert parse_rate_str('80bps') == {'rate_bps': '80'}
  60         assert parse_rate_str('80kbps') == {'rate_bps': '80000'}
  61         assert parse_rate_str('80kBps') == {'rate_bps': '640000'}
  62         assert parse_rate_str('80Mbps') == {'rate_bps': '80000000'}
  63         assert parse_rate_str('80 MBps') == {'rate_bps': '640000000'}
  64         assert parse_rate_str('80Gbps') == {'rate_bps': '80000000000'}
  65     except Exception as exc:
  66         assert False, exc.message
  67
  68     def should_raise_error(str):
  69         try:
  70             parse_rate_str(str)
  71         except Exception:
  72             return True
  73         else:
  74             return False
  75         return False
  76
  77     assert should_raise_error('101')
  78     assert should_raise_error('201%')
  79     assert should_raise_error('10Kbps')
  80     assert should_raise_error('0kbps')
  81     assert should_raise_error('0pps')
  82     assert should_raise_error('-1bps')
  83
  84
  85 def test_rate_conversion():
  86     assert traffic_utils.load_to_bps(50, 10000000000) == pytest.approx(5000000000.0)
  87     assert traffic_utils.load_to_bps(37, 10000000000) == pytest.approx(3700000000.0)
  88     assert traffic_utils.load_to_bps(100, 10000000000) == pytest.approx(10000000000.0)
  89
  90     assert traffic_utils.bps_to_load(5000000000.0, 10000000000) == pytest.approx(50.0)
  91     assert traffic_utils.bps_to_load(3700000000.0, 10000000000) == pytest.approx(37.0)
  92     assert traffic_utils.bps_to_load(10000000000.0, 10000000000) == pytest.approx(100.0)
  93
  94     assert traffic_utils.bps_to_pps(500000, 64) == pytest.approx(744.047619048)
  95     assert traffic_utils.bps_to_pps(388888, 1518) == pytest.approx(31.6066319896)
  96     assert traffic_utils.bps_to_pps(9298322222, 340.3) == pytest.approx(3225895.85831)
  97
  98     assert traffic_utils.pps_to_bps(744.047619048, 64) == pytest.approx(500000)
  99     assert traffic_utils.pps_to_bps(31.6066319896, 1518) == pytest.approx(388888)
 100     assert traffic_utils.pps_to_bps(3225895.85831, 340.3) == pytest.approx(9298322222)
 101
 102
 103 # pps at 10Gbps line rate for 64 byte frames
 104 LR_64B_PPS = 14880952
 105 LR_1518B_PPS = 812743
 106
 107 def assert_equivalence(reference, value, allowance_pct=1):
 108     """Assert if a value is equivalent to a reference value with given margin.
 109
 110     :param float reference: reference value to compare to
 111     :param float value: value to compare to reference
 112     :param float allowance_pct: max allowed percentage of margin
 113         0 : requires exact match
 114         1 : must be equal within 1% of the reference value
 115         ...
 116         100: always true
 117     """
 118     if reference == 0:
 119         assert value == 0
 120     else:
 121         assert abs(value - reference) * 100 / reference <= allowance_pct
 122
 123 def test_load_from_rate():
 124     assert traffic_utils.get_load_from_rate('100%') == 100
 125     assert_equivalence(100, traffic_utils.get_load_from_rate(str(LR_64B_PPS) + 'pps'))
 126     assert_equivalence(50, traffic_utils.get_load_from_rate(str(LR_64B_PPS / 2) + 'pps'))
 127     assert_equivalence(100, traffic_utils.get_load_from_rate('10Gbps'))
 128     assert_equivalence(50, traffic_utils.get_load_from_rate('5000Mbps'))
 129     assert_equivalence(1, traffic_utils.get_load_from_rate('100Mbps'))
 130     assert_equivalence(100, traffic_utils.get_load_from_rate(str(LR_1518B_PPS) + 'pps',
 131                                                              avg_frame_size=1518))
 132     assert_equivalence(100, traffic_utils.get_load_from_rate(str(LR_1518B_PPS * 2) + 'pps',
 133                                                              avg_frame_size=1518,
 134                                                              line_rate='20Gbps'))
 135
 136 # =========================================================================
 137 # Other tests
 138 # =========================================================================
 139
 140 def test_no_credentials():
 141     cred = Credentials('/completely/wrong/path/openrc', None, False)
 142     if cred.rc_auth_url:
 143         # shouldn't get valid data unless user set environment variables
 144         assert False
 145     else:
 146         assert True
 147
 148 def test_ip_block():
 149     ipb = IpBlock('10.0.0.0', '0.0.0.1', 256)
 150     assert ipb.get_ip() == '10.0.0.0'
 151     assert ipb.get_ip(255) == '10.0.0.255'
 152     with pytest.raises(IndexError):
 153         ipb.get_ip(256)
 154     ipb = IpBlock('10.0.0.0', '0.0.0.1', 1)
 155     assert ipb.get_ip() == '10.0.0.0'
 156     with pytest.raises(IndexError):
 157         ipb.get_ip(1)
 158
 159     ipb = IpBlock('10.0.0.0', '0.0.0.2', 256)
 160     assert ipb.get_ip() == '10.0.0.0'
 161     assert ipb.get_ip(1) == '10.0.0.2'
 162     assert ipb.get_ip(127) == '10.0.0.254'
 163     assert ipb.get_ip(128) == '10.0.1.0'
 164     with pytest.raises(IndexError):
 165         ipb.get_ip(256)
 166
 167     # verify with step larger than 1
 168     ipb = IpBlock('10.0.0.0', '0.0.0.2', 256)
 169     assert ipb.get_ip() == '10.0.0.0'
 170     assert ipb.get_ip(1) == '10.0.0.2'
 171     assert ipb.get_ip(128) == '10.0.1.0'
 172     assert ipb.get_ip(255) == '10.0.1.254'
 173     with pytest.raises(IndexError):
 174         ipb.get_ip(256)
 175
 176     ipb = IpBlock('10.0.0.0', '0.0.0.2', 128)
 177     assert ipb.get_ip() == '10.0.0.0'
 178     assert ipb.get_ip(1) == '10.0.0.2'
 179     assert ipb.get_ip(127) == '10.0.0.254'
 180     with pytest.raises(IndexError):
 181         ipb.get_ip(128)
 182
 183     ipb = IpBlock('10.0.0.0', '0.0.0.4', 64)
 184     assert ipb.get_ip() == '10.0.0.0'
 185     assert ipb.get_ip(1) == '10.0.0.4'
 186     assert ipb.get_ip(63) == '10.0.0.252'
 187     with pytest.raises(IndexError):
 188         ipb.get_ip(64)
 189
 190     ipb = IpBlock('10.0.0.0', '0.0.0.10', 1)
 191     assert ipb.get_ip() == '10.0.0.0'
 192     with pytest.raises(IndexError):
 193         ipb.get_ip(1)
 194
 195
 196 def test_lcm():
 197     assert Device.lcm(10, 2) == 10
 198     assert Device.lcm(1, 256) == 256
 199     assert Device.lcm(10, 256) == 1280
 200     assert Device.lcm(Device.lcm(10, 2), Device.lcm(1, 256))
 201     with pytest.raises(TypeError):
 202         Device.lcm(0, 0)
 203
 204
 205 def test_check_ipsize():
 206     assert Device.check_ipsize(256, 1) == 256
 207     assert Device.check_ipsize(256, 3) == 86
 208     assert Device.check_ipsize(256, 4) == 64
 209     assert Device.check_ipsize(16, 10) == 2
 210     assert Device.check_ipsize(1, 10) == 1
 211     with pytest.raises(ZeroDivisionError):
 212         Device.check_ipsize(256, 0)
 213
 214
 215 def test_reserve_ip_range():
 216     ipb = IpBlock('10.0.0.0', '0.0.0.1', 256)
 217     src_ip_first, src_ip_last = ipb.reserve_ip_range(256, False)
 218     assert src_ip_first == "10.0.0.0"
 219     assert src_ip_last == "10.0.0.255"
 220     ipb = IpBlock('20.0.0.0', '0.0.0.1', 2)
 221     src_ip_first, src_ip_last = ipb.reserve_ip_range(2, False)
 222     assert src_ip_first == "20.0.0.0"
 223     assert src_ip_last == "20.0.0.1"
 224     ipb = IpBlock('30.0.0.0', '0.0.0.1', 2)
 225     src_ip_first, src_ip_last = ipb.reserve_ip_range(256, True)
 226     assert src_ip_first == "30.0.0.0"
 227     assert src_ip_last == "30.0.0.1"
 228     ipb = IpBlock('40.0.0.0', '0.0.0.1', 2)
 229     with pytest.raises(IndexError):
 230         ipb.reserve_ip_range(256, False)
 231
 232
 233 def check_stream_configs(gen_config):
 234     """Verify that the range for each chain have adjacent IP ranges without holes between chains."""
 235     config = gen_config.config
 236     tgc = config['traffic_generator']
 237     step = Device.ip_to_int(tgc['ip_addrs_step'])
 238     cfc = 0
 239     sip = Device.ip_to_int(tgc['ip_addrs'][0].split('/')[0])
 240     dip = Device.ip_to_int(tgc['ip_addrs'][1].split('/')[0])
 241     stream_configs = gen_config.devices[0].get_stream_configs()
 242     for index in range(config['service_chain_count']):
 243         stream_cfg = stream_configs[index]
 244         assert stream_cfg['ip_src_count'] == stream_cfg['ip_dst_count']
 245         assert Device.ip_to_int(stream_cfg['ip_src_addr']) == sip
 246         assert Device.ip_to_int(stream_cfg['ip_dst_addr']) == dip
 247         count = stream_cfg['ip_src_count']
 248         cfc += count
 249         sip += count * step
 250         dip += count * step
 251     assert cfc == int(config['flow_count'] / 2)
 252
 253 def _check_device_flow_config(step_ip):
 254     config = _get_dummy_tg_config('PVP', '1Mpps', scc=10, fc=99999, step_ip=step_ip)
 255     gen_config = GeneratorConfig(config)
 256     check_stream_configs(gen_config)
 257
 258 def test_device_flow_config():
 259     _check_device_flow_config('0.0.0.1')
 260     _check_device_flow_config('0.0.0.2')
 261
 262
 263 def check_udp_stream_configs(gen_config, expected):
 264     """Verify that the range for each chain have adjacent UDP ports without holes between chains."""
 265     config = gen_config.config
 266     stream_configs = gen_config.devices[0].get_stream_configs()
 267     for index in range(config['service_chain_count']):
 268         stream_cfg = stream_configs[index]
 269         assert stream_cfg['ip_src_addr'] == expected['ip_src_addr']
 270         assert stream_cfg['ip_src_addr_max'] == expected['ip_src_addr_max']
 271         assert stream_cfg['ip_dst_addr'] == expected['ip_dst_addr']
 272         assert stream_cfg['ip_dst_addr_max'] == expected['ip_dst_addr_max']
 273         assert stream_cfg['udp_src_port'] == expected['udp_src_port']
 274         assert stream_cfg['udp_src_port_max'] == expected['udp_src_port_max']
 275         assert stream_cfg['udp_src_count'] == expected['udp_src_count']
 276         assert stream_cfg['udp_dst_port'] == expected['udp_dst_port']
 277         assert stream_cfg['udp_dst_port_max'] == expected['udp_dst_port_max']
 278         assert stream_cfg['udp_dst_count'] == expected['udp_dst_count']
 279
 280
 281 def _check_device_udp_flow_config(param, expected):
 282     config = _get_dummy_tg_config('PVP', '1Mpps',
 283                                   ip_src_static=param['ip_src_static'],
 284                                   fc=param['flow_count'],
 285                                   ip0=param['ip_src_addr'],
 286                                   ip1=param['ip_dst_addr'],
 287                                   src_udp=param['udp_src_port'],
 288                                   dst_udp=param['udp_dst_port'])
 289     gen_config = GeneratorConfig(config)
 290     check_udp_stream_configs(gen_config, expected)
 291
 292
 293 def test_device_udp_flow_config():
 294     param = {'ip_src_static': True,
 295              'ip_src_addr': '110.0.0.0/32',
 296              'ip_dst_addr': '120.0.0.0/32',
 297              'udp_src_port': 53,
 298              'udp_dst_port': 53,
 299              'flow_count': 2}
 300     expected = {'ip_src_addr': '110.0.0.0',
 301                 'ip_src_addr_max': '110.0.0.0',
 302                 'ip_dst_addr': '120.0.0.0',
 303                 'ip_dst_addr_max': '120.0.0.0',
 304                 'udp_src_port': 53,
 305                 'udp_src_port_max': 53,
 306                 'udp_src_count': 1,
 307                 'udp_dst_port': 53,
 308                 'udp_dst_port_max': 53,
 309                 'udp_dst_count': 1}
 310     _check_device_udp_flow_config(param, expected)
 311     # Overwrite the udp_src_port value to define a large range of ports
 312     # instead of a single port, in order to check if the imposed
 313     # flow count is respected. Notice that udp range >> flow count.
 314     param['udp_src_port'] = [53, 1024]
 315     param['flow_count'] = 10
 316     expected['udp_src_port_max'] = 57
 317     expected['udp_src_count'] = 5
 318     _check_device_udp_flow_config(param, expected)
 319     # Re affect the default udp_src_port values and
 320     # overwrite the ip_dst_addr value to define a large range of addresses
 321     # instead of a single one, in order to check if the imposed
 322     # flow count is respected. Notice that the netmask allows a very larger
 323     # range of possible addresses than the flow count value.
 324     param['udp_src_port'] = 53
 325     expected['udp_src_port_max'] = 53
 326     expected['udp_src_count'] = 1
 327     param['ip_src_static'] = False
 328     param['ip_dst_addr'] = '120.0.0.0/24'
 329     expected['ip_dst_addr'] = '120.0.0.0'
 330     expected['ip_dst_addr_max'] = '120.0.0.4'
 331     _check_device_udp_flow_config(param, expected)
 332
 333
 334 def test_config():
 335     refcfg = {1: 100, 2: {21: 100, 22: 200}, 3: None}
 336     res1 = {1: 10, 2: {21: 100, 22: 200}, 3: None}
 337     res2 = {1: 100, 2: {21: 1000, 22: 200}, 3: None}
 338     res3 = {1: 100, 2: {21: 100, 22: 200}, 3: "abc"}
 339     assert config_loads("{}", refcfg) == refcfg
 340     assert config_loads("{1: 10}", refcfg) == res1
 341     assert config_loads("{2: {21: 1000}}", refcfg) == res2
 342     assert config_loads('{3: "abc"}', refcfg) == res3
 343
 344     # correctly fails
 345     # pairs of input string and expected subset (None if identical)
 346     fail_pairs = [
 347         ["{4: 0}", None],
 348         ["{2: {21: 100, 30: 50}}", "{2: {30: 50}}"],
 349         ["{2: {0: 1, 1: 2}, 5: 5}", None],
 350         ["{1: 'abc', 2: {21: 0}}", "{1: 'abc'}"],
 351         ["{2: 100}", None]
 352     ]
 353     for fail_pair in fail_pairs:
 354         with pytest.raises(Exception) as e_info:
 355             config_loads(fail_pair[0], refcfg)
 356         expected = fail_pair[1]
 357         if expected is None:
 358             expected = fail_pair[0]
 359         assert expected in str(e_info)
 360
 361     # whitelist keys
 362     flavor = {'flavor': {'vcpus': 2, 'ram': 8192, 'disk': 0,
 363                          'extra_specs': {'hw:cpu_policy': 'dedicated'}}}
 364     new_flavor = {'flavor': {'vcpus': 2, 'ram': 8192, 'disk': 0,
 365                              'extra_specs': {'hw:cpu_policy': 'dedicated', 'hw:numa_nodes': 2}}}
 366     assert config_loads("{'flavor': {'extra_specs': {'hw:numa_nodes': 2}}}", flavor,
 367                         whitelist_keys=['alpha', 'extra_specs']) == new_flavor
 368
 369
 370 def test_fluentd():
 371     logger = logging.getLogger('fluent-logger')
 372
 373     class FluentdConfig(dict):
 374         def __getattr__(self, attr):
 375             return self.get(attr)
 376
 377     fluentd_configs = [
 378         FluentdConfig({
 379             'logging_tag': 'nfvbench',
 380             'result_tag': 'resultnfvbench',
 381             'ip': '127.0.0.1',
 382             'port': 7081
 383         }),
 384         FluentdConfig({
 385             'logging_tag': 'nfvbench',
 386             'result_tag': 'resultnfvbench',
 387             'ip': '127.0.0.1',
 388             'port': 24224
 389         }),
 390         FluentdConfig({
 391             'logging_tag': None,
 392             'result_tag': 'resultnfvbench',
 393             'ip': '127.0.0.1',
 394             'port': 7082
 395         }),
 396         FluentdConfig({
 397             'logging_tag': 'nfvbench',
 398             'result_tag': None,
 399             'ip': '127.0.0.1',
 400             'port': 7083
 401         })
 402     ]
 403
 404     handler = FluentLogHandler(fluentd_configs=fluentd_configs)
 405     logger.addHandler(handler)
 406     logger.setLevel(logging.INFO)
 407     logger.info('test')
 408     logger.warning('test %d', 100)
 409
 410     try:
 411         raise Exception("test")
 412     except Exception:
 413         logger.exception("got exception")
 414
 415 def assert_ndr_pdr(stats, ndr, ndr_dr, pdr, pdr_dr):
 416     assert stats['ndr']['rate_percent'] == ndr
 417     assert stats['ndr']['stats']['overall']['drop_percentage'] == ndr_dr
 418     assert_equivalence(pdr, stats['pdr']['rate_percent'])
 419     assert_equivalence(pdr_dr, stats['pdr']['stats']['overall']['drop_percentage'])
 420
 421 def _get_dummy_tg_config(chain_type, rate, scc=1, fc=10, step_ip='0.0.0.1',
 422                          ip0='10.0.0.0/8', ip1='20.0.0.0/8',
 423                          step_udp=1, src_udp=None, dst_udp=None, ip_src_static=True):
 424     return AttrDict({
 425         'traffic_generator': {'host_name': 'nfvbench_tg',
 426                               'default_profile': 'dummy',
 427                               'generator_profile': [{'name': 'dummy',
 428                                                      'tool': 'dummy',
 429                                                      'ip': '127.0.0.1',
 430                                                      'intf_speed': '10Gbps',
 431                                                      'interfaces': [{'port': 0, 'pci': '0.0'},
 432                                                                     {'port': 1, 'pci': '0.0'}]}],
 433                               'ip_addrs_step': step_ip,
 434                               'ip_addrs': [ip0, ip1],
 435                               'ip_src_static': ip_src_static,
 436                               'tg_gateway_ip_addrs': ['1.1.0.100', '2.2.0.100'],
 437                               'tg_gateway_ip_addrs_step': step_ip,
 438                               'gateway_ip_addrs': ['1.1.0.2', '2.2.0.2'],
 439                               'gateway_ip_addrs_step': step_ip,
 440                               'mac_addrs_left': None,
 441                               'mac_addrs_right': None,
 442                               'udp_src_port': src_udp,
 443                               'udp_dst_port': dst_udp,
 444                               'udp_port_step': step_udp},
 445         'traffic': {'profile': 'profile_64',
 446                     'bidirectional': True},
 447         'traffic_profile': [{'name': 'profile_64', 'l2frame_size': ['64']}],
 448         'generator_profile': None,
 449         'service_chain': chain_type,
 450         'service_chain_count': scc,
 451         'flow_count': fc,
 452         'vlan_tagging': True,
 453         'no_arp': False,
 454         'duration_sec': 1,
 455         'interval_sec': 1,
 456         'pause_sec': 1,
 457         'rate': rate,
 458         'check_traffic_time_sec': 200,
 459         'generic_poll_sec': 2,
 460         'measurement': {'NDR': 0.001, 'PDR': 0.1, 'load_epsilon': 0.1},
 461         'l2_loopback': False,
 462         'cores': None,
 463         'mbuf_factor': None,
 464         'disable_hdrh': None,
 465         'mbuf_64': None,
 466         'service_mode': False,
 467         'no_flow_stats': False,
 468         'no_latency_stats': False,
 469         'no_latency_streams': False
 470
 471     })
 472
 473 def _get_traffic_client():
 474     config = _get_dummy_tg_config('PVP', 'ndr_pdr')
 475     config['vxlan'] = False
 476     config['mpls'] = False
 477     config['ndr_run'] = True
 478     config['pdr_run'] = True
 479     config['generator_profile'] = 'dummy'
 480     config['single_run'] = False
 481     traffic_client = TrafficClient(config)
 482     traffic_client.start_traffic_generator()
 483     traffic_client.set_traffic('64', True)
 484     return traffic_client
 485
 486 @patch.object(TrafficClient, 'skip_sleep', lambda x: True)
 487 def test_ndr_at_lr():
 488     """Test NDR at line rate."""
 489     traffic_client = _get_traffic_client()
 490     tg = traffic_client.gen
 491     # this is a perfect sut with no loss at LR
 492     tg.set_response_curve(lr_dr=0, ndr=100, max_actual_tx=100, max_11_tx=100)
 493     # tx packets should be line rate for 64B and no drops...
 494     assert tg.get_tx_pps_dropped_pps(100) == (LR_64B_PPS, 0)
 495     # NDR and PDR should be at 100%
 496     # traffic_client.ensure_end_to_end()
 497     results = traffic_client.get_ndr_and_pdr()
 498     assert_ndr_pdr(results, 200.0, 0.0, 200.0, 0.0)
 499
 500 @patch.object(TrafficClient, 'skip_sleep', lambda x: True)
 501 def test_ndr_at_50():
 502     """Test NDR at 50% line rate.
 503
 504     This is a sut with an NDR of 50% and linear drop rate after NDR up to 20% drops at LR
 505     (meaning that if you send 100% TX, you will only receive 80% RX)
 506     the tg requested TX/actual TX ratio is up to 50%, after 50%
 507     is linear up 80% actuak TX when requesting 100%
 508     """
 509     traffic_client = _get_traffic_client()
 510     tg = traffic_client.gen
 511
 512     tg.set_response_curve(lr_dr=20, ndr=50, max_actual_tx=80, max_11_tx=50)
 513     # tx packets should be half line rate for 64B and no drops...
 514     assert tg.get_tx_pps_dropped_pps(50) == (LR_64B_PPS / 2, 0)
 515     # at 100% TX requested, actual TX is 80% where the drop rate is 3/5 of 20% of the actual TX
 516     assert tg.get_tx_pps_dropped_pps(100) == (int(LR_64B_PPS * 0.8),
 517                                               int(LR_64B_PPS * 0.8 * 0.6 * 0.2))
 518     results = traffic_client.get_ndr_and_pdr()
 519     assert_ndr_pdr(results, 100.0, 0.0, 100.781, 0.09374)
 520
 521 @patch.object(TrafficClient, 'skip_sleep', lambda x: True)
 522 def test_ndr_pdr_low_cpu():
 523     """Test NDR and PDR with too low cpu.
 524
 525     This test is for the case where the TG is underpowered and cannot send fast enough for the NDR
 526     true NDR=40%, actual TX at 50% = 30%, actual measured DR is 0%
 527     The ndr/pdr should bail out with a warning and a best effort measured NDR of 30%
 528     """
 529     traffic_client = _get_traffic_client()
 530     tg = traffic_client.gen
 531     tg.set_response_curve(lr_dr=50, ndr=40, max_actual_tx=60, max_11_tx=0)
 532     # tx packets should be 30% at requested half line rate for 64B and no drops...
 533     assert tg.get_tx_pps_dropped_pps(50) == (int(LR_64B_PPS * 0.3), 0)
 534     results = traffic_client.get_ndr_and_pdr()
 535     assert results
 536     # import pprint
 537     # pp = pprint.PrettyPrinter(indent=4)
 538     # pp.pprint(results)
 539
 540 @patch.object(TrafficClient, 'skip_sleep', lambda x: True)
 541 def test_no_openstack():
 542     """Test nfvbench using main."""
 543     config = _get_dummy_tg_config('EXT', '1000pps')
 544     config.openrc_file = None
 545     config.vlans = [[100], [200]]
 546     config['traffic_generator']['mac_addrs_left'] = ['00:00:00:00:00:00']
 547     config['traffic_generator']['mac_addrs_right'] = ['00:00:00:00:01:00']
 548     del config['generator_profile']
 549     old_argv = sys.argv
 550     sys.argv = [old_argv[0], '-c', json.dumps(config)]
 551     nfvbench.nfvbench.main()
 552     sys.argv = old_argv