yardstick/tests/unit/network_services/vnf_generic/vnf/test_prox_helpers.py

   1 # Copyright (c) 2016-2018 Intel Corporation
   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 from itertools import repeat, chain
  16 import os
  17 import socket
  18 import time
  19
  20 import mock
  21 import unittest
  22
  23 from yardstick.common import utils
  24 from yardstick.network_services import constants
  25 from yardstick.network_services.vnf_generic.vnf import base as vnf_base
  26 from yardstick.network_services.vnf_generic.vnf import prox_helpers
  27 from yardstick.network_services.vnf_generic.vnf import sample_vnf
  28
  29
  30 class TestCoreTuple(unittest.TestCase):
  31     def test___init__(self):
  32         core_tuple = prox_helpers.CoreSocketTuple('core 5s6')
  33         self.assertEqual(core_tuple.core_id, 5)
  34         self.assertEqual(core_tuple.socket_id, 6)
  35         self.assertFalse(core_tuple.is_hyperthread())
  36
  37         core_tuple = prox_helpers.CoreSocketTuple('core 5s6h')
  38         self.assertEqual(core_tuple.core_id, 5)
  39         self.assertEqual(core_tuple.socket_id, 6)
  40         self.assertTrue(core_tuple.is_hyperthread())
  41
  42     def test___init__negative(self):
  43         bad_inputs = [
  44             '',
  45             '5',
  46             '5s',
  47             '6h',
  48             '5s6',
  49             'core',
  50             'core h',
  51             'core 5s',
  52             'core 5 6',
  53             'core 5 6h',
  54             'core 5d6',
  55             'core 5d6h',
  56             1,
  57             2.3,
  58             [],
  59             {},
  60             object(),
  61         ]
  62
  63         for bad_input in bad_inputs:
  64             with self.assertRaises(ValueError):
  65                 prox_helpers.CoreSocketTuple(bad_input)
  66
  67     def test_find_in_topology(self):
  68         topology_in = {
  69             6: {
  70                 5: {
  71                     'key1': ['a', 'b'],
  72                     'key2': ['c', 'd'],
  73                 },
  74             },
  75         }
  76
  77         core_tuple = prox_helpers.CoreSocketTuple('core 5s6')
  78
  79         expected = 'a'
  80         result = core_tuple.find_in_topology(topology_in)
  81         self.assertEqual(result, expected)
  82
  83         core_tuple = prox_helpers.CoreSocketTuple('core 5s6h')
  84
  85         expected = 'c'
  86         result = core_tuple.find_in_topology(topology_in)
  87         self.assertEqual(result, expected)
  88
  89     def test_find_in_topology_negative(self):
  90         core_tuple = prox_helpers.CoreSocketTuple('core 6s5')
  91         with self.assertRaises(ValueError):
  92             # no socket key
  93             core_tuple.find_in_topology({})
  94
  95         with self.assertRaises(ValueError):
  96             # no core key
  97             core_tuple.find_in_topology({5: {}})
  98
  99         with self.assertRaises(ValueError):
 100             # no first value (as needed by non-hyperthread core)
 101             core_tuple.find_in_topology({5: {6: {'key1': []}}})
 102
 103         core_tuple = prox_helpers.CoreSocketTuple('core 6s5h')
 104         with self.assertRaises(ValueError):
 105             # no second value (as needed by hyperthread core)
 106             core_tuple.find_in_topology({5: {6: {'key1': ['e']}}})
 107
 108
 109 class TestTotStatsTuple(unittest.TestCase):
 110     def test___new___negative(self):
 111         with self.assertRaises(TypeError):
 112             # no values
 113             prox_helpers.TotStatsTuple()
 114
 115         with self.assertRaises(TypeError):
 116             # one, non-integer value
 117             prox_helpers.TotStatsTuple('a')
 118
 119         with self.assertRaises(TypeError):
 120             # too many values
 121             prox_helpers.TotStatsTuple(3, 4, 5, 6, 7)
 122
 123
 124 class TestProxTestDataTuple(unittest.TestCase):
 125     def test___init__(self):
 126         prox_test_data = prox_helpers.ProxTestDataTuple(
 127             1, 2, 3, 4, 5, 6, 7, 8, 9)
 128         self.assertEqual(prox_test_data.tolerated, 1)
 129         self.assertEqual(prox_test_data.tsc_hz, 2)
 130         self.assertEqual(prox_test_data.delta_rx, 3)
 131         self.assertEqual(prox_test_data.delta_tx, 4)
 132         self.assertEqual(prox_test_data.delta_tsc, 5)
 133         self.assertEqual(prox_test_data.latency, 6)
 134         self.assertEqual(prox_test_data.rx_total, 7)
 135         self.assertEqual(prox_test_data.tx_total, 8)
 136         self.assertEqual(prox_test_data.requested_pps, 9)
 137
 138     def test_properties(self):
 139         prox_test_data = prox_helpers.ProxTestDataTuple(
 140             1, 2, 3, 4, 5, 6, 7, 8, 9)
 141         self.assertEqual(prox_test_data.pkt_loss, 12.5)
 142         self.assertEqual(prox_test_data.tx_mpps, 1.6 / 1e6)
 143         self.assertEqual(prox_test_data.can_be_lost, 0)
 144         self.assertEqual(prox_test_data.drop_total, 1)
 145         self.assertFalse(prox_test_data.success)
 146
 147         prox_test_data = prox_helpers.ProxTestDataTuple(
 148             10, 2, 3, 4, 5, 6, 997, 998, 9)
 149         self.assertTrue(prox_test_data.success)
 150
 151     def test_pkt_loss_zero_division(self):
 152         prox_test_data = prox_helpers.ProxTestDataTuple(
 153             1, 2, 3, 4, 5, 6, 7, 0, 9)
 154         self.assertEqual(prox_test_data.pkt_loss, 100.0)
 155
 156     def test_get_samples(self):
 157         prox_test_data = prox_helpers.ProxTestDataTuple(
 158             1, 2, 3, 4, 5, [6.1, 6.9, 6.4], 7, 8, 9)
 159
 160         expected = {
 161             "Throughput": 1.2 / 1e6,
 162             "DropPackets": 12.5,
 163             "CurrentDropPackets": 12.5,
 164             "RequestedTxThroughput": 9 / 1e6,
 165             "TxThroughput": 1.6 / 1e6,
 166             "RxThroughput": 1.2 / 1e6,
 167             "PktSize": 64,
 168             "PortSample": 1,
 169             "LatencyMin": 6.1,
 170             "LatencyMax": 6.9,
 171             "LatencyAvg": 6.4,
 172         }
 173         result = prox_test_data.get_samples(64, port_samples={"PortSample": 1})
 174         self.assertDictEqual(result, expected)
 175
 176         expected = {
 177             "Throughput": 1.2 / 1e6,
 178             "DropPackets": 0.123,
 179             "CurrentDropPackets": 0.123,
 180             "RequestedTxThroughput": 9 / 1e6,
 181             "TxThroughput": 1.6 / 1e6,
 182             "RxThroughput": 1.2 / 1e6,
 183             "PktSize": 64,
 184             "LatencyMin": 6.1,
 185             "LatencyMax": 6.9,
 186             "LatencyAvg": 6.4,
 187         }
 188         result = prox_test_data.get_samples(64, 0.123)
 189         self.assertDictEqual(result, expected)
 190
 191     @mock.patch('yardstick.LOG_RESULT', create=True)
 192     def test_log_data(self, mock_logger):
 193         my_mock_logger = mock.MagicMock()
 194         prox_test_data = prox_helpers.ProxTestDataTuple(
 195             1, 2, 3, 4, 5, [6.1, 6.9, 6.4], 7, 8, 9)
 196         prox_test_data.log_data()
 197
 198         my_mock_logger.debug.assert_not_called()
 199         mock_logger.debug.assert_not_called()
 200
 201         mock_logger.debug.reset_mock()
 202         prox_test_data.log_data(my_mock_logger)
 203         my_mock_logger.assert_not_called()
 204         mock_logger.debug.assert_not_called()
 205
 206
 207 class TestPacketDump(unittest.TestCase):
 208     PAYLOAD = "payload"
 209
 210     def test__init__(self):
 211         prox_helpers.PacketDump("port_id", len(self.PAYLOAD), self.PAYLOAD)
 212
 213     def test___str__(self):
 214         expected = '<PacketDump port: port_id payload: {}>'.format(self.PAYLOAD)
 215         dump1 = prox_helpers.PacketDump(
 216             "port_id", len(self.PAYLOAD), self.PAYLOAD)
 217         self.assertEqual(str(dump1), expected)
 218
 219     def test_port_id(self):
 220         p = prox_helpers.PacketDump("port_id", len(self.PAYLOAD), self.PAYLOAD)
 221         self.assertEqual(p.port_id, "port_id")
 222
 223     def test_data_len(self):
 224         p = prox_helpers.PacketDump("port_id", len(self.PAYLOAD), self.PAYLOAD)
 225         self.assertEqual(p.data_len, len(self.PAYLOAD))
 226
 227     def test_payload(self):
 228         p = prox_helpers.PacketDump("port_id", len(self.PAYLOAD), self.PAYLOAD)
 229         self.assertEqual(p.payload(), self.PAYLOAD)
 230
 231         self.assertEqual(p.payload(3), self.PAYLOAD[3:])
 232
 233         self.assertEqual(p.payload(end=3), self.PAYLOAD[:4])
 234
 235         self.assertEqual(p.payload(2, 4), self.PAYLOAD[2:5])
 236
 237
 238 PACKET_DUMP_1 = """\
 239 pktdump,3,11
 240 hello world
 241 """
 242
 243 PACKET_DUMP_2 = """\
 244 pktdump,3,11
 245 hello world
 246 pktdump,2,9
 247 brown fox jumped over
 248 pktdump,4,8
 249 lazy
 250 dog
 251 """
 252
 253 PACKET_DUMP_NON_1 = """\
 254 not_a_dump,1,2
 255 other data
 256 """
 257
 258 PACKET_DUMP_MIXED_1 = """\
 259 pktdump,3,11
 260 hello world
 261 not_a_dump,1,2
 262 other data
 263 """
 264
 265 PACKET_DUMP_BAD_1 = """\
 266 pktdump,one,12
 267 bad port id
 268 """
 269
 270 PACKET_DUMP_BAD_2 = """\
 271 pktdump,3,twelve
 272 bad data length
 273 """
 274
 275 PACKET_DUMP_BAD_3 = """\
 276 pktdump,3
 277 no data length value
 278 """
 279
 280
 281 class TestProxSocketHelper(unittest.TestCase):
 282
 283     def setUp(self):
 284         self._mock_time_sleep = mock.patch.object(time, 'sleep')
 285         self.mock_time_sleep = self._mock_time_sleep.start()
 286         self.addCleanup(self._stop_mocks)
 287
 288     def _stop_mocks(self):
 289         self._mock_time_sleep.stop()
 290
 291     @mock.patch.object(prox_helpers, 'socket')
 292     def test___init__(self, mock_socket):
 293         expected = mock_socket.socket()
 294         prox = prox_helpers.ProxSocketHelper()
 295         result = prox._sock
 296         self.assertEqual(result, expected)
 297
 298     def test_connect(self):
 299         mock_sock = mock.MagicMock()
 300         prox = prox_helpers.ProxSocketHelper(mock_sock)
 301         prox.connect('10.20.30.40', 23456)
 302         mock_sock.connect.assert_called_once()
 303
 304     def test_get_sock(self):
 305         mock_sock = mock.MagicMock()
 306         prox = prox_helpers.ProxSocketHelper(mock_sock)
 307         result = prox.get_socket()
 308         self.assertIs(result, mock_sock)
 309
 310     # TODO(elfoley): Split this into three tests
 311     @mock.patch.object(prox_helpers, 'select')
 312     def test_get_data(self, mock_select):
 313         mock_select.select.side_effect = [[1], [0]]
 314         mock_socket = mock.MagicMock()
 315         mock_recv = mock_socket.recv()
 316         mock_recv.decode.return_value = ""
 317         prox = prox_helpers.ProxSocketHelper(mock_socket)
 318         ret = prox.get_data()
 319         self.assertEqual(ret, "")
 320         self.assertEqual(len(prox._pkt_dumps), 0)
 321
 322         mock_select.select.reset_mock()
 323         mock_select.select.side_effect = chain([['a'], ['']],
 324                                                repeat([1], 3))
 325         mock_recv.decode.return_value = PACKET_DUMP_1
 326         ret = prox.get_data()
 327         self.assertEqual(mock_select.select.call_count, 2)
 328         self.assertEqual(ret, 'pktdump,3,11')
 329         self.assertEqual(len(prox._pkt_dumps), 1)
 330
 331         mock_select.select.reset_mock()
 332         mock_select.select.side_effect = chain([[object()], [None]],
 333                                                repeat([1], 3))
 334         mock_recv.decode.return_value = PACKET_DUMP_2
 335         ret = prox.get_data()
 336         self.assertEqual(mock_select.select.call_count, 1)
 337         self.assertEqual(ret, 'jumped over')
 338         self.assertEqual(len(prox._pkt_dumps), 3)
 339
 340     @mock.patch.object(prox_helpers, 'select')
 341     def test_get_string(self, mock_select):
 342         mock_select.select.side_effect = [[1], [0]]
 343         mock_socket = mock.MagicMock()
 344         mock_recv = mock_socket.recv()
 345         mock_recv.decode.return_value = ""
 346         prox = prox_helpers.ProxSocketHelper(mock_socket)
 347         status, ret = prox.get_string()
 348         self.assertEqual(ret, "")
 349         self.assertTrue(status)
 350         self.assertEqual(len(prox._pkt_dumps), 0)
 351
 352     @mock.patch.object(prox_helpers, 'select')
 353     def test_get_string2(self, mock_select):
 354         mock_select.select.side_effect = chain([['a'], ['']],
 355                                                repeat([1], 3))
 356         mock_socket = mock.MagicMock()
 357         mock_recv = mock_socket.recv()
 358         mock_recv.decode.return_value = PACKET_DUMP_1
 359         prox = prox_helpers.ProxSocketHelper(mock_socket)
 360         status, ret = prox.get_string()
 361         self.assertEqual(mock_select.select.call_count, 2)
 362         self.assertEqual(ret, 'pktdump,3,11')
 363         self.assertTrue(status)
 364         self.assertEqual(len(prox._pkt_dumps), 1)
 365
 366     @mock.patch.object(prox_helpers, 'select')
 367     def test_get_string3(self, mock_select):
 368         mock_select.select.side_effect = chain([[object()], [None]],
 369                                                repeat([1], 3))
 370         mock_socket = mock.MagicMock()
 371         mock_recv = mock_socket.recv()
 372         mock_recv.decode.return_value = PACKET_DUMP_2
 373         prox = prox_helpers.ProxSocketHelper(mock_socket)
 374         status, ret = prox.get_string()
 375         self.assertTrue(status)
 376         self.assertTrue(mock_select.select.assert_called_once)
 377         self.assertEqual(ret, 'jumped over')
 378         self.assertEqual(len(prox._pkt_dumps), 2)
 379
 380     def test__parse_socket_data_mixed_data(self):
 381         prox = prox_helpers.ProxSocketHelper(mock.MagicMock())
 382         ret, _ = prox._parse_socket_data(PACKET_DUMP_NON_1, False)
 383         self.assertEqual(ret, 'not_a_dump,1,2')
 384         self.assertEqual(len(prox._pkt_dumps), 0)
 385
 386         ret, _ = prox._parse_socket_data(PACKET_DUMP_MIXED_1, False)
 387         self.assertEqual(ret, 'not_a_dump,1,2')
 388         self.assertEqual(len(prox._pkt_dumps), 1)
 389
 390     def test__parse_socket_data_bad_data(self):
 391         prox = prox_helpers.ProxSocketHelper(mock.MagicMock())
 392         with self.assertRaises(ValueError):
 393             prox._parse_socket_data(PACKET_DUMP_BAD_1, False)
 394
 395         with self.assertRaises(ValueError):
 396             prox._parse_socket_data(PACKET_DUMP_BAD_2, False)
 397
 398         ret, _ = prox._parse_socket_data(PACKET_DUMP_BAD_3, False)
 399         self.assertEqual(ret, 'pktdump,3')
 400
 401     def test__parse_socket_data_pkt_dump_only(self):
 402         prox = prox_helpers.ProxSocketHelper(mock.MagicMock())
 403         ret, _ = prox._parse_socket_data('', True)
 404         self.assertFalse(ret)
 405
 406         ret, _ = prox._parse_socket_data(PACKET_DUMP_1, True)
 407         self.assertTrue(ret)
 408
 409         ret, _ = prox._parse_socket_data(PACKET_DUMP_2, True)
 410         self.assertTrue(ret)
 411
 412     def test_put_command(self):
 413         mock_socket = mock.MagicMock()
 414         prox = prox_helpers.ProxSocketHelper(mock_socket)
 415         prox.put_command("data")
 416         mock_socket.sendall.assert_called_once()
 417
 418     def test_put_command_socket_error(self):
 419         mock_socket = mock.MagicMock()
 420         mock_socket.sendall.side_effect = OSError
 421         prox = prox_helpers.ProxSocketHelper(mock_socket)
 422         prox.put_command("data")
 423         mock_socket.sendall.assert_called_once()
 424
 425     def test_get_packet_dump(self):
 426         mock_socket = mock.MagicMock()
 427         prox = prox_helpers.ProxSocketHelper(mock_socket)
 428         prox._pkt_dumps = []
 429         self.assertIsNone(prox.get_packet_dump())
 430
 431         prox._pkt_dumps = [234]
 432         self.assertEqual(prox.get_packet_dump(), 234)
 433         self.assertEqual(prox._pkt_dumps, [])
 434
 435     def test_stop_all_reset(self):
 436         mock_socket = mock.MagicMock()
 437         prox = prox_helpers.ProxSocketHelper(mock_socket)
 438         prox.stop_all_reset()
 439         mock_socket.sendall.assert_called()
 440
 441     def test_stop_all(self):
 442         mock_socket = mock.MagicMock()
 443         prox = prox_helpers.ProxSocketHelper(mock_socket)
 444         prox.stop_all()
 445         mock_socket.sendall.assert_called()
 446
 447     def test_stop(self):
 448         mock_socket = mock.MagicMock()
 449         prox = prox_helpers.ProxSocketHelper(mock_socket)
 450         prox.stop([3, 4, 5], 16)
 451         mock_socket.sendall.assert_called()
 452
 453     def test_start_all(self):
 454         mock_socket = mock.MagicMock()
 455         prox = prox_helpers.ProxSocketHelper(mock_socket)
 456         prox.start_all()
 457         mock_socket.sendall.assert_called()
 458
 459     def test_start(self):
 460         mock_socket = mock.MagicMock()
 461         prox = prox_helpers.ProxSocketHelper(mock_socket)
 462         prox.start([3, 4, 5])
 463         mock_socket.sendall.assert_called()
 464
 465     def test_reset_stats(self):
 466         mock_socket = mock.MagicMock()
 467         prox = prox_helpers.ProxSocketHelper(mock_socket)
 468         prox.reset_stats()
 469         mock_socket.sendall.assert_called()
 470
 471     def test_set_pkt_size(self):
 472         mock_socket = mock.MagicMock()
 473         prox = prox_helpers.ProxSocketHelper(mock_socket)
 474         prox.set_pkt_size([3, 4, 5], 1024)
 475         self.assertEqual(mock_socket.sendall.call_count, 3)
 476
 477     def test_set_value(self):
 478         mock_socket = mock.MagicMock()
 479         prox = prox_helpers.ProxSocketHelper(mock_socket)
 480         prox.set_value([3, 4, 5], 10, 20, 30)
 481         self.assertEqual(mock_socket.sendall.call_count, 3)
 482
 483     def test_reset_values(self):
 484         mock_socket = mock.MagicMock()
 485         prox = prox_helpers.ProxSocketHelper(mock_socket)
 486         prox.reset_values([3, 4, 5])
 487         self.assertEqual(mock_socket.sendall.call_count, 3)
 488
 489     def test_set_speed(self):
 490         mock_socket = mock.MagicMock()
 491         prox = prox_helpers.ProxSocketHelper(mock_socket)
 492         prox.set_speed([3, 4, 5], 1000)
 493         self.assertEqual(mock_socket.sendall.call_count, 3)
 494
 495     def test_slope_speed(self):
 496         core_data = [
 497             {
 498                 'cores': [3, 4, 5],
 499                 'speed': 1000,
 500             },
 501             {
 502                 'cores': [9, 10, 11],
 503                 'speed': '500.5',
 504             },
 505         ]
 506
 507         mock_socket = mock.MagicMock()
 508         prox = prox_helpers.ProxSocketHelper(mock_socket)
 509         prox.set_speed = set_speed = mock.MagicMock()
 510         prox.slope_speed(core_data, 5)
 511         self.assertEqual(set_speed.call_count, 20)
 512
 513         set_speed.reset_mock()
 514         prox.slope_speed(core_data, 5, 5)
 515         self.assertEqual(set_speed.call_count, 10)
 516
 517     def test_set_pps(self):
 518         mock_socket = mock.MagicMock()
 519         prox = prox_helpers.ProxSocketHelper(mock_socket)
 520         prox.set_pps([3, 4, 5], 1000, 512)
 521         self.assertEqual(mock_socket.sendall.call_count, 3)
 522
 523     def test_lat_stats(self):
 524         latency_output = [
 525             '1, 2 , 3',  # has white space
 526             '4,5',  # too short
 527             '7,8,9,10.5,11',  # too long with float, but float is in unused portion
 528             'twelve,13,14',  # value as English word
 529             '15,16.2,17',  # float in used portion
 530         ]
 531
 532         mock_socket = mock.MagicMock()
 533         prox = prox_helpers.ProxSocketHelper(mock_socket)
 534         prox.get_data = mock.MagicMock(side_effect=latency_output)
 535
 536         expected = (
 537             {
 538                 3: 1,
 539                 5: 7,
 540             },
 541             {
 542                 3: 2,
 543                 5: 8,
 544             },
 545             {
 546                 3: 3,
 547                 5: 9,
 548             },
 549         )
 550         result = prox.lat_stats([3, 4, 5, 6, 7], 16)
 551         self.assertEqual(mock_socket.sendall.call_count, 5)
 552         self.assertEqual(result, expected)
 553
 554     def test_get_all_tot_stats_error(self):
 555         mock_socket = mock.MagicMock()
 556         prox = prox_helpers.ProxSocketHelper(mock_socket)
 557         prox.get_data = mock.MagicMock(return_value='3,4,5')
 558         expected = [0, 0, 0, 0]
 559         result = prox.get_all_tot_stats()
 560         self.assertEqual(result, expected)
 561
 562     def test_get_all_tot_stats(self):
 563         mock_socket = mock.MagicMock()
 564         prox = prox_helpers.ProxSocketHelper(mock_socket)
 565         prox.get_data = mock.MagicMock(return_value='3,4,5,6')
 566         expected = 3, 4, 5, 6
 567         result = prox.get_all_tot_stats()
 568         self.assertEqual(result, expected)
 569
 570     def test_hz(self):
 571         mock_socket = mock.MagicMock()
 572         prox = prox_helpers.ProxSocketHelper(mock_socket)
 573         prox.get_data = mock.MagicMock(return_value='3,4,5,6')
 574         expected = 6
 575         result = prox.hz()
 576         self.assertEqual(result, expected)
 577
 578     def test_core_stats(self):
 579         core_stats = [
 580             '3,4,5,6',
 581             '7,8,9,10,NaN',
 582             '11,12,13,14,15',
 583         ]
 584
 585         mock_socket = mock.MagicMock()
 586         prox = prox_helpers.ProxSocketHelper(mock_socket)
 587         prox.get_data = mock.MagicMock(side_effect=core_stats)
 588         expected = 21, 24, 27, 14
 589         result = prox.core_stats([3, 4, 5], 16)
 590         self.assertEqual(result, expected)
 591
 592     @mock.patch.object(prox_helpers.LOG, 'error')
 593     def test_multi_port_stats(self, *args):
 594         mock_socket = mock.MagicMock()
 595         prox = prox_helpers.ProxSocketHelper(mock_socket)
 596         prox.get_string = mock.MagicMock(return_value=(True, '0,1,2,3,4,5;1,1,2,3,4,5'))
 597         expected = [[0, 1, 2, 3, 4, 5], [1, 1, 2, 3, 4, 5]]
 598         status, result = prox.multi_port_stats([0, 1])
 599         self.assertEqual(result, expected)
 600         self.assertEqual(status, True)
 601
 602         prox.get_string = mock.MagicMock(
 603             return_value=(True, '0,1,2,3,4,5;1,1,2,3,4,5'))
 604         status, result = prox.multi_port_stats([0])
 605         self.assertEqual(status, False)
 606
 607         prox.get_string = mock.MagicMock(
 608             return_value=(True, '0,1,2,3,4,5;1,1,2,3,4,5'))
 609         status, result = prox.multi_port_stats([0, 1, 2])
 610         self.assertEqual(status, False)
 611
 612         prox.get_string = mock.MagicMock(
 613             return_value=(True, '0,1,2,3;1,1,2,3,4,5'))
 614         status, result = prox.multi_port_stats([0, 1])
 615         self.assertEqual(status, False)
 616
 617         prox.get_string = mock.MagicMock(
 618             return_value=(True, '99,1,2,3,4,5;1,1,2,3,4,5'))
 619         status, result = prox.multi_port_stats([0, 1])
 620         self.assertEqual(status, False)
 621
 622         prox.get_string = mock.MagicMock(
 623             return_value=(True, '99,1,2,3,4,5;1,1,2,3,4,5'))
 624         status, result = prox.multi_port_stats([99, 1])
 625         expected = [[99, 1, 2, 3, 4, 5], [1, 1, 2, 3, 4, 5]]
 626         self.assertEqual(status, True)
 627         self.assertEqual(result, expected)
 628
 629         prox.get_string = mock.MagicMock(
 630             return_value=(True,
 631                           '2,21,22,23,24,25;1,11,12,13,14,15;0,1,2,3,4,5'))
 632
 633         sample1 = [0, 1, 2, 3, 4, 5]
 634         sample2 = [1, 11, 12, 13, 14, 15]
 635         sample3 = [2, 21, 22, 23, 24, 25]
 636         expected = [sample3, sample2, sample1]
 637         status, result = prox.multi_port_stats([1, 2, 0])
 638         self.assertTrue(status)
 639         self.assertListEqual(result, expected)
 640
 641         prox.get_string = mock.MagicMock(
 642             return_value=(True, '6,21,22,23,24,25;1,11,12,13,14,15;0,1,2,3,4,5'))
 643         ok, result = prox.multi_port_stats([1, 6, 0])
 644         sample1 = [6, 21, 22, 23, 24, 25]
 645         sample2 = [1, 11, 12, 13, 14, 15]
 646         sample3 = [0, 1, 2, 3, 4, 5]
 647         expected = [sample1, sample2, sample3]
 648         self.assertListEqual(result, expected)
 649         self.assertTrue(ok)
 650
 651     @mock.patch.object(prox_helpers.LOG, 'error')
 652     def test_multi_port_stats_diff(self, *args):
 653         mock_socket = mock.MagicMock()
 654         prox = prox_helpers.ProxSocketHelper(mock_socket)
 655         prox.get_string = mock.MagicMock(return_value=(True, '0,1,2,3,4,5;1,1,2,3,4,5'))
 656         _, t1 = prox.multi_port_stats([0, 1])
 657
 658         prox.get_string = mock.MagicMock(return_value=(True, '0,2,4,6,8,6;1,4,8,16,32,6'))
 659         _, t2 = prox.multi_port_stats([0, 1])
 660
 661         prox.get_string = mock.MagicMock(return_value=(True, '0,1,1,1,1,1;1,1,1,1,1,1'))
 662         _, t3 = prox.multi_port_stats([0, 1])
 663
 664         prox.get_string = mock.MagicMock(return_value=(True, '0,2,2,2,2,2;1,2,2,2,2,2'))
 665         _, t4 = prox.multi_port_stats([0, 1])
 666
 667         expected = [[0, 1.0, 2.0, 0, 0, 1], [1, 3.0, 6.0, 0, 0, 1]]
 668         result = prox.multi_port_stats_diff(t1, t2, 1)
 669
 670         self.assertListEqual(result, expected)
 671
 672         result = prox.multi_port_stats_diff(t4, t3, 1)
 673         expected = [[0, 1.0, 1.0, 0, 0, 1], [1, 1.0, 1.0, 0, 0, 1]]
 674
 675         self.assertListEqual(result, expected)
 676
 677         prox.get_string = mock.MagicMock(return_value=(True, '0,2,4,6,8,10'))
 678         ok, t5 = prox.multi_port_stats([0, 1])
 679         self.assertFalse(ok)
 680         self.assertListEqual(t5, [])
 681
 682         result = prox.multi_port_stats_diff(t5, t4, 1)
 683         expected = [[0, 0.0, 0.0, 0, 0, 0], [1, 0.0, 0.0, 0, 0, 0]]
 684         self.assertListEqual(result, expected)
 685
 686         prox.get_string = mock.MagicMock(return_value=(True, '0,10,10,20,30,0;1,30,40,50,60,0'))
 687         _, t6 = prox.multi_port_stats([0, 1])
 688
 689         prox.get_string = \
 690             mock.MagicMock(return_value=(True, '0,100,100,100,100,0;1,100,100,100,100,0'))
 691         _, t7 = prox.multi_port_stats([0, 1])
 692
 693         result = prox.multi_port_stats_diff(t6, t7, 1)
 694         expected = [[0, 0.0, 0.0, 0, 0, 0], [1, 0.0, 0.0, 0, 0, 0]]
 695         self.assertListEqual(result, expected)
 696
 697         result = prox.multi_port_stats_diff(t1, t2, 0)
 698         expected = [[0, 0.0, 0.0, 0, 0, 1], [1, 0.0, 0.0, 0, 0, 1]]
 699         self.assertListEqual(result, expected)
 700
 701     @mock.patch.object(prox_helpers.LOG, 'error')
 702     def test_multi_port_stats_tuple(self, *args):
 703         mock_socket = mock.MagicMock()
 704         prox = prox_helpers.ProxSocketHelper(mock_socket)
 705         prox.get_string = mock.MagicMock(return_value=(True, '0,1,2,3,4,5;1,1,2,3,4,5'))
 706         _, result1 = prox.multi_port_stats([0, 1])
 707         prox.get_string = mock.MagicMock(return_value=(True, '0,2,4,6,8,6;1,4,8,16,32,6'))
 708         _, result2 = prox.multi_port_stats([0, 1])
 709
 710         result = prox.multi_port_stats_diff(result1, result2, 1)
 711
 712         vnfd_helper = mock.MagicMock()
 713         vnfd_helper.ports_iter.return_value = [('xe0', 0), ('xe1', 1)]
 714
 715         expected = {'xe0': {'in_packets': 1.0, 'out_packets': 2.0},
 716                     'xe1': {'in_packets': 3.0, 'out_packets': 6.0}}
 717         live_stats = prox.multi_port_stats_tuple(result, vnfd_helper.ports_iter())
 718         self.assertDictEqual(live_stats, expected)
 719
 720         live_stats = prox.multi_port_stats_tuple(result, None)
 721         expected = {}
 722         self.assertDictEqual(live_stats, expected)
 723
 724         live_stats = prox.multi_port_stats_tuple(None, vnfd_helper.ports_iter())
 725         self.assertDictEqual(live_stats, expected)
 726
 727     def test_port_stats(self):
 728         port_stats = [
 729             ','.join(str(n) for n in range(3, 15)),
 730             ','.join(str(n) for n in range(8, 32, 2)),
 731             ','.join(str(n) for n in range(5, 89, 7)),
 732         ]
 733
 734         mock_socket = mock.MagicMock()
 735         prox = prox_helpers.ProxSocketHelper(mock_socket)
 736         prox.get_data = mock.MagicMock(side_effect=port_stats)
 737         expected = [16, 26, 36, 46, 56, 66, 76, 86, 96, 106, 116, 126]
 738         result = prox.port_stats([3, 4, 5])
 739         self.assertEqual(result, expected)
 740
 741     def test_measure_tot_stats(self):
 742         start_tot = 3, 4, 5, 6
 743         end_tot = 7, 9, 11, 13
 744         delta_tot = 4, 5, 6, 7
 745
 746         get_data_output = [
 747             ','.join(str(n) for n in start_tot),
 748             ','.join(str(n) for n in end_tot),
 749         ]
 750
 751         mock_socket = mock.MagicMock()
 752         prox = prox_helpers.ProxSocketHelper(mock_socket)
 753         prox.get_data = mock.MagicMock(side_effect=get_data_output)
 754         expected = {
 755             'start_tot': start_tot,
 756             'end_tot': end_tot,
 757             'delta': delta_tot,
 758         }
 759         with prox.measure_tot_stats() as result:
 760             pass
 761         self.assertEqual(result, expected)
 762
 763     def test_tot_stats(self):
 764         mock_socket = mock.MagicMock()
 765         prox = prox_helpers.ProxSocketHelper(mock_socket)
 766         prox.get_data = mock.MagicMock(return_value='3,4,5,6')
 767         expected = 3, 4, 5
 768         result = prox.tot_stats()
 769         self.assertEqual(result, expected)
 770
 771     def test_tot_ierrors(self):
 772         mock_socket = mock.MagicMock()
 773         prox = prox_helpers.ProxSocketHelper(mock_socket)
 774         prox.get_data = mock.MagicMock(return_value='3,4,5,6')
 775         expected = 3, 3
 776         result = prox.tot_ierrors()
 777         self.assertEqual(result, expected)
 778
 779     def test_set_count(self):
 780         mock_socket = mock.MagicMock()
 781         prox = prox_helpers.ProxSocketHelper(mock_socket)
 782         prox.set_count(432, [3, 4, 5])
 783         self.assertEqual(mock_socket.sendall.call_count, 3)
 784
 785     def test_dump_rx(self):
 786         mock_socket = mock.MagicMock()
 787         prox = prox_helpers.ProxSocketHelper(mock_socket)
 788         prox.dump_rx(3, 5, 8)
 789         mock_socket.sendall.assert_called_once()
 790
 791     def test_quit(self):
 792         mock_socket = mock.MagicMock()
 793         prox = prox_helpers.ProxSocketHelper(mock_socket)
 794         prox.quit()
 795         mock_socket.sendall.assert_called()
 796
 797     def test_force_quit(self):
 798         mock_socket = mock.MagicMock()
 799         prox = prox_helpers.ProxSocketHelper(mock_socket)
 800         prox.force_quit()
 801         mock_socket.sendall.assert_called()
 802
 803
 804 class TestProxDpdkVnfSetupEnvHelper(unittest.TestCase):
 805
 806     VNFD0 = {
 807         'short-name': 'ProxVnf',
 808         'vdu': [
 809             {
 810                 'routing_table': [
 811                     {
 812                         'network': '152.16.100.20',
 813                         'netmask': '255.255.255.0',
 814                         'gateway': '152.16.100.20',
 815                         'if': 'xe0',
 816                     },
 817                     {
 818                         'network': '152.16.40.20',
 819                         'netmask': '255.255.255.0',
 820                         'gateway': '152.16.40.20',
 821                         'if': 'xe1',
 822                     },
 823                 ],
 824                 'description': 'PROX approximation using DPDK',
 825                 'name': 'proxvnf-baremetal',
 826                 'nd_route_tbl': [
 827                     {
 828                         'network': '0064:ff9b:0:0:0:0:9810:6414',
 829                         'netmask': '112',
 830                         'gateway': '0064:ff9b:0:0:0:0:9810:6414',
 831                         'if': 'xe0',
 832                     },
 833                     {
 834                         'network': '0064:ff9b:0:0:0:0:9810:2814',
 835                         'netmask': '112',
 836                         'gateway': '0064:ff9b:0:0:0:0:9810:2814',
 837                         'if': 'xe1',
 838                     },
 839                 ],
 840                 'id': 'proxvnf-baremetal',
 841                 'external-interface': [
 842                     {
 843                         'virtual-interface': {
 844                             'dst_mac': '00:00:00:00:00:04',
 845                             'vpci': '0000:05:00.0',
 846                             'local_ip': '152.16.100.19',
 847                             'type': 'PCI-PASSTHROUGH',
 848                             'vld_id': 'uplink_0',
 849                             'netmask': '255.255.255.0',
 850                             'dpdk_port_num': 0,
 851                             'bandwidth': '10 Gbps',
 852                             'driver': "i40e",
 853                             'dst_ip': '152.16.100.19',
 854                             'local_iface_name': 'xe0',
 855                             'local_mac': '00:00:00:00:00:02',
 856                             'ifname': 'xe0',
 857                         },
 858                         'vnfd-connection-point-ref': 'xe0',
 859                         'name': 'xe0',
 860                     },
 861                     {
 862                         'virtual-interface': {
 863                             'dst_mac': '00:00:00:00:00:03',
 864                             'vpci': '0000:05:00.1',
 865                             'local_ip': '152.16.40.19',
 866                             'type': 'PCI-PASSTHROUGH',
 867                             'vld_id': 'downlink_0',
 868                             'driver': "i40e",
 869                             'netmask': '255.255.255.0',
 870                             'dpdk_port_num': 1,
 871                             'bandwidth': '10 Gbps',
 872                             'dst_ip': '152.16.40.20',
 873                             'local_iface_name': 'xe1',
 874                             'local_mac': '00:00:00:00:00:01',
 875                             'ifname': 'xe1',
 876                         },
 877                         'vnfd-connection-point-ref': 'xe1',
 878                         'name': 'xe1',
 879                     },
 880                 ],
 881             },
 882         ],
 883         'description': 'PROX approximation using DPDK',
 884         'mgmt-interface': {
 885             'vdu-id': 'proxvnf-baremetal',
 886             'host': '1.2.1.1',
 887             'password': 'r00t',
 888             'user': 'root',
 889             'ip': '1.2.1.1',
 890         },
 891         'benchmark': {
 892             'kpi': [
 893                 'packets_in',
 894                 'packets_fwd',
 895                 'packets_dropped',
 896             ],
 897         },
 898         'id': 'ProxApproxVnf',
 899         'name': 'ProxVnf',
 900     }
 901
 902     VNFD = {
 903         'vnfd:vnfd-catalog': {
 904             'vnfd': [
 905                 VNFD0,
 906             ],
 907         },
 908     }
 909
 910     def test_global_section(self):
 911         setup_helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
 912             mock.MagicMock(), mock.MagicMock(), mock.MagicMock())
 913
 914         setup_helper._prox_config_data = [('a', [])]
 915
 916         with self.assertRaises(KeyError):
 917             _ = setup_helper.global_section
 918
 919         global_section = (
 920             'global', [
 921                 ('not_name', 'other data'),
 922                 ('name_not', 'more data'),
 923                 ('name', 'prox type'),
 924             ],
 925         )
 926
 927         setup_helper._prox_config_data = [
 928             ('section1', []),
 929             ('section2', [
 930                 ('a', 'b'),
 931                 ('c', 'd'),
 932             ]),
 933             ('core 1', []),
 934             ('core 2', [
 935                 ('index', 8),
 936                 ('mode', ''),
 937             ]),
 938             global_section,
 939             ('core 3', [
 940                 ('index', 5),
 941                 ('mode', 'gen'),
 942                 ('name', 'tagged'),
 943             ]),
 944             ('section3', [
 945                 ('key1', 'value1'),
 946                 ('key2', 'value2'),
 947                 ('key3', 'value3'),
 948             ]),
 949             ('core 4', [
 950                 ('index', 7),
 951                 ('mode', 'gen'),
 952                 ('name', 'udp'),
 953             ]),
 954         ]
 955
 956         result = setup_helper.global_section
 957         self.assertEqual(result, global_section[1])
 958
 959     def test_find_in_section(self):
 960         setup_helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
 961             mock.MagicMock(), mock.MagicMock(), mock.MagicMock())
 962
 963         setup_helper._prox_config_data = [
 964             ('global', [
 965                 ('not_name', 'other data'),
 966                 ('name_not', 'more data'),
 967                 ('name', 'prox type'),
 968             ]),
 969             ('section1', []),
 970             ('section2', [
 971                 ('a', 'b'),
 972                 ('c', 'd'),
 973             ]),
 974             ('core 1', []),
 975             ('core 2', [
 976                 ('index', 8),
 977                 ('mode', ''),
 978             ]),
 979             ('core 3', [
 980                 ('index', 5),
 981                 ('mode', 'gen'),
 982                 ('name', 'tagged'),
 983             ]),
 984             ('section3', [
 985                 ('key1', 'value1'),
 986                 ('key2', 'value2'),
 987                 ('key3', 'value3'),
 988             ]),
 989             ('core 4', [
 990                 ('index', 7),
 991                 ('mode', 'gen'),
 992                 ('name', 'udp'),
 993             ]),
 994         ]
 995
 996         expected = 'value3'
 997         result = setup_helper.find_in_section('section3', 'key3')
 998         self.assertEqual(result, expected)
 999
1000         expected = 'default value'
1001         result = setup_helper.find_in_section('section3', 'key4', 'default value')
1002         self.assertEqual(result, expected)
1003
1004         with self.assertRaises(KeyError):
1005             setup_helper.find_in_section('section4', 'key1')
1006
1007         with self.assertRaises(KeyError):
1008             setup_helper.find_in_section('section1', 'key1')
1009
1010     def test__replace_quoted_with_value(self):
1011         # empty string
1012         input_str = ''
1013         expected = ''
1014         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1015                   _replace_quoted_with_value(input_str, 'cat'))
1016         self.assertEqual(result, expected)
1017
1018         # no quoted substring
1019         input_str = 'lion tiger bear'
1020         expected = 'lion tiger bear'
1021         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1022                   _replace_quoted_with_value(input_str, 'cat'))
1023         self.assertEqual(result, expected)
1024
1025         # partially quoted substring
1026         input_str = 'lion "tiger bear'
1027         expected = 'lion "tiger bear'
1028         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1029                   _replace_quoted_with_value(input_str, 'cat'))
1030         self.assertEqual(result, expected)
1031
1032         # one quoted substring
1033         input_str = 'lion "tiger" bear'
1034         expected = 'lion "cat" bear'
1035         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1036                   _replace_quoted_with_value(input_str, 'cat'))
1037         self.assertEqual(result, expected)
1038
1039         # two quoted substrings
1040         input_str = 'lion "tiger" bear "shark" whale'
1041         expected = 'lion "cat" bear "shark" whale'
1042         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1043                   _replace_quoted_with_value(input_str, 'cat'))
1044         self.assertEqual(result, expected)
1045
1046         # two quoted substrings, both replaced
1047         input_str = 'lion "tiger" bear "shark" whale'
1048         expected = 'lion "cat" bear "cat" whale'
1049         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1050                   _replace_quoted_with_value(input_str, 'cat', 2))
1051         self.assertEqual(result, expected)
1052
1053     def test__get_tx_port(self):
1054         # no data
1055         input_data = {'section1': []}
1056         expected = -1
1057         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1058                   _get_tx_port('section1', input_data))
1059         self.assertEqual(result, expected)
1060
1061         # data for other section
1062         input_data = {
1063             'section1': [],
1064             'section2': [
1065                 ('rx port', '3'),
1066                 ('tx port', '4'),
1067             ],
1068         }
1069         expected = -1
1070         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1071                   _get_tx_port('section1', input_data))
1072         self.assertEqual(result, expected)
1073
1074         # data for section
1075         input_data['section1'] = section1 = [
1076             ('rx port', '4', 'more', 432),
1077             ('tx port', '3'),
1078         ]
1079         expected = 3
1080         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1081                   _get_tx_port('section1', input_data))
1082         self.assertEqual(result, expected)
1083
1084         # more data for section,
1085         section1.extend([
1086             ('rx port', '2'),
1087             ('tx port', '1', 'and more', 234),
1088         ])
1089         expected = 1
1090         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1091                   _get_tx_port('section1', input_data))
1092         self.assertEqual(result, expected)
1093
1094     # TODO(elfoley): Split this into several smaller tests
1095     def test_write_prox_config(self):
1096         input_data = {}
1097         expected = ''
1098         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1099                   write_prox_config(input_data))
1100         self.assertEqual(result, expected)
1101
1102         input_data = [
1103             [
1104                 'section1',
1105                 [],
1106             ],
1107         ]
1108         expected = '[section1]'
1109         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1110                   write_prox_config(input_data))
1111         self.assertEqual(result, expected)
1112
1113         input_data = [
1114             [
1115                 'section1',
1116                 [],
1117             ],
1118             [
1119                 'section2',
1120                 [
1121                     ['key1', 'value1'],
1122                     ['__name__', 'not this one'],
1123                     ['key2', None],
1124                     ['key3', 234],
1125                     ['key4', 'multi-line\nvalue'],
1126                 ],
1127             ],
1128         ]
1129         expected = os.linesep.join([
1130             '[section1]',
1131             '[section2]',
1132             'key1=value1',
1133             'key2',
1134             'key3=234',
1135             'key4=multi-line\n\tvalue',
1136         ])
1137         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1138                   write_prox_config(input_data))
1139         self.assertEqual(result, expected)
1140
1141     def test_prox_config_data(self):
1142         setup_helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1143             mock.MagicMock(), mock.MagicMock(), mock.MagicMock())
1144
1145         setup_helper.config_queue = config_queue = mock.MagicMock()
1146         config_queue.get.return_value = expected = [('s', [('a', 3), ('b', 45)])]
1147
1148         result = setup_helper.prox_config_data
1149         self.assertEqual(result, expected)
1150
1151     @mock.patch.object(utils, 'find_relative_file')
1152     def test_build_config_file_no_additional_file(self, mock_find_path):
1153         vnf1 = {
1154             'prox_args': {'-c': ""},
1155             'prox_path': 'd',
1156             'prox_config': 'e/f',
1157             'prox_generate_parameter': False,
1158         }
1159
1160         mock_find_path.side_effect = ['1', '2']
1161
1162         vnfd_helper = mock.MagicMock()
1163         ssh_helper = mock.MagicMock()
1164         scenario_helper = sample_vnf.ScenarioHelper('vnf1')
1165         scenario_helper.scenario_cfg = {
1166             'task_path': 'a/b',
1167             'options': {
1168                 'vnf1': vnf1,
1169             },
1170         }
1171
1172         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1173             vnfd_helper, ssh_helper, scenario_helper)
1174         helper.copy_to_target = mock.MagicMock(return_value='3')
1175         helper.generate_prox_config_file = mock.MagicMock(return_value='4')
1176         helper.upload_prox_config = mock.MagicMock(return_value='5')
1177
1178         self.assertEqual(helper.additional_files, {})
1179         self.assertNotEqual(helper._prox_config_data, '4')
1180         self.assertNotEqual(helper.remote_path, '5')
1181         helper.build_config_file()
1182         self.assertEqual(helper.additional_files, {})
1183         self.assertEqual(helper._prox_config_data, '4')
1184         self.assertEqual(helper.remote_path, '5')
1185
1186     @mock.patch.object(utils, 'find_relative_file')
1187     def test_build_config_file_additional_file_string(self, mock_find_path):
1188         vnf1 = {
1189             'prox_args': {'-c': ""},
1190             'prox_path': 'd',
1191             'prox_config': 'e/f',
1192             'prox_files': 'g/h.i',
1193             'prox_generate_parameter': True,
1194         }
1195
1196         mock_find_path.side_effect = ['1', '2']
1197         vnfd_helper = mock.MagicMock()
1198         ssh_helper = mock.MagicMock()
1199         scenario_helper = sample_vnf.ScenarioHelper('vnf1')
1200         scenario_helper.scenario_cfg = {
1201             'task_path': 'a/b',
1202             'options': {
1203                 'vnf1': vnf1,
1204             },
1205         }
1206
1207         vnfd_helper.port_pairs.all_ports = ['xe0', 'xe1', 'xe2', 'xe3']
1208         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1209             vnfd_helper, ssh_helper, scenario_helper)
1210         helper.copy_to_target = mock.MagicMock(side_effect=['33', '34', '35'])
1211         helper.generate_prox_config_file = mock.MagicMock(return_value='44')
1212         helper.upload_prox_config = mock.MagicMock(return_value='55')
1213
1214         self.assertEqual(helper.additional_files, {})
1215         expected = {'h.i': '33'}
1216         helper.build_config_file()
1217         self.assertDictEqual(helper.additional_files, expected)
1218
1219     @mock.patch.object(utils, 'find_relative_file')
1220     def test_build_config_file_additional_file(self, mock_find_path):
1221         vnf1 = {
1222             'prox_args': {'-c': ""},
1223             'prox_path': 'd',
1224             'prox_config': 'e/f',
1225             'prox_files': [
1226                 'g/h.i',
1227                 'j/k/l',
1228                 'm_n',
1229             ],
1230         }
1231
1232         mock_find_path.side_effect = ['1', '2'] + [str(i) for i in range(len(vnf1['prox_files']))]
1233         vnfd_helper = mock.MagicMock()
1234         ssh_helper = mock.MagicMock()
1235         scenario_helper = sample_vnf.ScenarioHelper('vnf1')
1236         scenario_helper.scenario_cfg = {
1237             'task_path': 'a/b',
1238             'options': {
1239                 'vnf1': vnf1,
1240             },
1241         }
1242
1243         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1244             vnfd_helper, ssh_helper, scenario_helper)
1245         helper.copy_to_target = mock.MagicMock(side_effect=['33', '34', '35'])
1246         helper.generate_prox_config_file = mock.MagicMock(return_value='44')
1247         helper.upload_prox_config = mock.MagicMock(return_value='55')
1248
1249         self.assertEqual(helper.additional_files, {})
1250         self.assertNotEqual(helper._prox_config_data, '44')
1251         self.assertNotEqual(helper.remote_path, '55')
1252         expected = {'h.i': '33', 'l': '34', 'm_n': '35'}
1253         helper.build_config_file()
1254         self.assertDictEqual(helper.additional_files, expected)
1255         self.assertEqual(helper._prox_config_data, '44')
1256         self.assertEqual(helper.remote_path, '55')
1257
1258     def test_build_config(self):
1259         vnf1 = {
1260             'prox_args': {'-f': ""},
1261             'prox_path': '/opt/nsb_bin/prox',
1262             'prox_config': 'configs/gen_l2fwd-2.cfg',
1263             'prox_files': [
1264                 'g/h.i',
1265                 'j/k/l',
1266                 'm_n',
1267             ],
1268         }
1269
1270         vnfd_helper = mock.Mock()
1271         ssh_helper = mock.Mock()
1272         ssh_helper.join_bin_path.return_value = '/opt/nsb_bin/prox'
1273         scenario_helper = sample_vnf.ScenarioHelper('vnf1')
1274         scenario_helper.scenario_cfg = {
1275             'task_path': 'a/b',
1276             'options': {
1277                 'vnf1': vnf1,
1278             },
1279         }
1280
1281         expected = ("sudo bash -c 'cd /opt/nsb_bin; /opt/nsb_bin/prox -o cli "
1282                     "-f  -f /tmp/prox.cfg '")
1283
1284         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1285             vnfd_helper, ssh_helper, scenario_helper)
1286         with mock.patch.object(helper, 'build_config_file') as mock_cfg_file:
1287             helper.remote_path = '/tmp/prox.cfg'
1288             prox_cmd = helper.build_config()
1289             self.assertEqual(prox_cmd, expected)
1290             mock_cfg_file.assert_called_once()
1291
1292     def test__insert_additional_file(self):
1293         vnfd_helper = mock.MagicMock()
1294         ssh_helper = mock.MagicMock()
1295         scenario_helper = mock.MagicMock()
1296
1297         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1298             vnfd_helper, ssh_helper, scenario_helper)
1299         helper.additional_files = {"ipv4.lua": "/tmp/ipv4.lua"}
1300         res = helper._insert_additional_file('dofile("ipv4.lua")')
1301         self.assertEqual(res, 'dofile("/tmp/ipv4.lua")')
1302
1303     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ConfigParser')
1304     def test_generate_prox_config_file(self, mock_parser_type):
1305         def init(*args):
1306             if sections_data:
1307                 args[-1].extend(sections_data)
1308             return mock.MagicMock()
1309
1310         sections_data = []
1311
1312         mock_parser_type.side_effect = init
1313
1314         vnfd_helper = vnf_base.VnfdHelper(self.VNFD0)
1315         ssh_helper = mock.MagicMock()
1316         scenario_helper = mock.MagicMock()
1317
1318         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1319             vnfd_helper, ssh_helper, scenario_helper)
1320         helper.additional_files = {}
1321
1322         expected = []
1323         result = helper.generate_prox_config_file('a/b')
1324         self.assertEqual(result, expected)
1325
1326         helper.additional_files = {"ipv4.lua": "/tmp/ipv4.lua"}
1327
1328         helper.remote_prox_file_name = 'remote'
1329         sections_data = [
1330             [
1331                 'lua',
1332                 [
1333                     ['dofile("ipv4.lua")', ''],
1334                 ],
1335             ],
1336             [
1337                 'port 0',
1338                 [
1339                     ['ip', ''],
1340                     ['mac', 'foo'],
1341                     ['dst mac', '@@1'],
1342                     ['tx port', '1'],
1343                 ],
1344             ],
1345             [
1346                 'port 2',
1347                 [
1348                     ['ip', ''],
1349                     ['$sut_mac0', '@@dst_mac0'],
1350                     ['tx port', '0'],
1351                     ['single', '@'],
1352                     ['user_table', 'dofile("ipv4.lua")'],
1353                     ['missing_addtional_file', 'dofile("nosuch")'],
1354                 ],
1355             ],
1356         ]
1357
1358         expected = [
1359             [
1360                 'lua',
1361                 [
1362                     ['dofile("/tmp/ipv4.lua")', ''],
1363                 ],
1364             ],
1365             [
1366                 'port 0',
1367                 [
1368                     ['ip', ''],
1369                     ['mac', 'hardware'],
1370                     ['dst mac', '00:00:00:00:00:03'],
1371                     ['tx port', '1'],
1372                 ],
1373             ],
1374             [
1375                 'port 2',
1376                 [
1377                     ['ip', ''],
1378                     ['$sut_mac0', '00 00 00 00 00 04'],
1379                     ['tx port', '0'],
1380                     ['single', '@'],
1381                     ['user_table', 'dofile("/tmp/ipv4.lua")'],
1382                     ['missing_addtional_file', 'dofile("nosuch")'],
1383                 ],
1384             ],
1385         ]
1386         result = helper.generate_prox_config_file('/c/d/e')
1387         self.assertEqual(result, expected, str(result))
1388
1389     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ConfigParser')
1390     def test_generate_prox_config_file_negative(self, mock_parser_type):
1391         def init(*args):
1392             args[-1].update(sections_data)
1393             return mock.MagicMock()
1394
1395         sections_data = {}
1396
1397         mock_parser_type.side_effect = init
1398
1399         vnfd_helper = mock.MagicMock()
1400         vnfd_helper.interfaces = []
1401         ssh_helper = mock.MagicMock()
1402         scenario_helper = mock.MagicMock()
1403
1404         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1405             vnfd_helper, ssh_helper, scenario_helper)
1406         helper.additional_files = {}
1407         helper.remote_prox_file_name = 'remote'
1408         vnfd_helper.interfaces = [
1409             {
1410                 'virtual-interface': {
1411                     'dpdk_port_num': 3,
1412                     'dst_mac': '00:00:00:de:ad:88',
1413                 },
1414             },
1415             {
1416                 'virtual-interface': {
1417                     'dpdk_port_num': 5,
1418                     'dst_mac': '00:00:00:de:ad:ff',
1419                 },
1420             },
1421             {
1422                 'virtual-interface': {
1423                     'dpdk_port_num': 7,
1424                     'dst_mac': '00:00:00:de:ad:ff',
1425                 },
1426             },
1427         ]
1428         sections_data = {
1429             'port 3': [
1430                 ['ip', ''],
1431                 ['mac', 'foo'],
1432                 ['dst mac', ''],
1433             ],
1434             'port 5': [
1435                 ['ip', ''],
1436                 ['dst mac', ''],
1437                 ['tx port', '0'],
1438                 ['???', 'dofile "here" 23'],
1439             ],
1440         }
1441
1442         with self.assertRaises(Exception):
1443             helper.generate_prox_config_file('a/b')
1444
1445     def test_put_string_to_file(self):
1446         vnfd_helper = mock.MagicMock()
1447         vnfd_helper.interfaces = []
1448         ssh_helper = mock.MagicMock()
1449         scenario_helper = mock.MagicMock()
1450
1451         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1452             vnfd_helper, ssh_helper, scenario_helper)
1453
1454         expected = 'a/b'
1455         result = helper.put_string_to_file('my long string', 'a/b')
1456         self.assertEqual(result, expected)
1457
1458     def test_copy_to_target(self):
1459         vnfd_helper = mock.MagicMock()
1460         vnfd_helper.interfaces = []
1461         ssh_helper = mock.MagicMock()
1462         scenario_helper = mock.MagicMock()
1463
1464         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1465             vnfd_helper, ssh_helper, scenario_helper)
1466         expected = '/tmp/c'
1467         result = helper.copy_to_target('a/b', 'c')
1468         self.assertEqual(result, expected)
1469
1470     def test_upload_prox_config(self):
1471         vnfd_helper = mock.MagicMock()
1472         vnfd_helper.interfaces = []
1473         ssh_helper = mock.MagicMock()
1474         scenario_helper = mock.MagicMock()
1475
1476         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1477             vnfd_helper, ssh_helper, scenario_helper)
1478         helper.write_prox_config = mock.MagicMock(return_value='a long string')
1479         expected = '/tmp/a'
1480         result = helper.upload_prox_config('a', {})
1481         self.assertEqual(result, expected)
1482
1483
1484 class TestProxResourceHelper(unittest.TestCase):
1485
1486     VNFD0 = {
1487         'short-name': 'ProxVnf',
1488         'vdu': [
1489             {
1490                 'routing_table': [
1491                     {
1492                         'network': '152.16.100.20',
1493                         'netmask': '255.255.255.0',
1494                         'gateway': '152.16.100.20',
1495                         'if': 'xe0',
1496                     },
1497                     {
1498                         'network': '152.16.40.20',
1499                         'netmask': '255.255.255.0',
1500                         'gateway': '152.16.40.20',
1501                         'if': 'xe1',
1502                     },
1503                 ],
1504                 'description': 'PROX approximation using DPDK',
1505                 'name': 'proxvnf-baremetal',
1506                 'nd_route_tbl': [
1507                     {
1508                         'network': '0064:ff9b:0:0:0:0:9810:6414',
1509                         'netmask': '112',
1510                         'gateway': '0064:ff9b:0:0:0:0:9810:6414',
1511                         'if': 'xe0',
1512                     },
1513                     {
1514                         'network': '0064:ff9b:0:0:0:0:9810:2814',
1515                         'netmask': '112',
1516                         'gateway': '0064:ff9b:0:0:0:0:9810:2814',
1517                         'if': 'xe1',
1518                     },
1519                 ],
1520                 'id': 'proxvnf-baremetal',
1521                 'external-interface': [
1522                     {
1523                         'virtual-interface': {
1524                             'dst_mac': '00:00:00:00:00:04',
1525                             'vpci': '0000:05:00.0',
1526                             'local_ip': '152.16.100.19',
1527                             'type': 'PCI-PASSTHROUGH',
1528                             'vld_id': 'uplink_0',
1529                             'netmask': '255.255.255.0',
1530                             'dpdk_port_num': 0,
1531                             'bandwidth': '10 Gbps',
1532                             'driver': "i40e",
1533                             'dst_ip': '152.16.100.19',
1534                             'local_iface_name': 'xe0',
1535                             'local_mac': '00:00:00:00:00:02',
1536                             'ifname': 'xe0',
1537                         },
1538                         'vnfd-connection-point-ref': 'xe0',
1539                         'name': 'xe0',
1540                     },
1541                     {
1542                         'virtual-interface': {
1543                             'dst_mac': '00:00:00:00:00:03',
1544                             'vpci': '0000:05:00.1',
1545                             'local_ip': '152.16.40.19',
1546                             'type': 'PCI-PASSTHROUGH',
1547                             'vld_id': 'downlink_0',
1548                             'driver': "i40e",
1549                             'netmask': '255.255.255.0',
1550                             'dpdk_port_num': 1,
1551                             'bandwidth': '10 Gbps',
1552                             'dst_ip': '152.16.40.20',
1553                             'local_iface_name': 'xe1',
1554                             'local_mac': '00:00:00:00:00:01',
1555                             'ifname': 'xe1',
1556                         },
1557                         'vnfd-connection-point-ref': 'xe1',
1558                         'name': 'xe1',
1559                     },
1560                 ],
1561             },
1562         ],
1563         'description': 'PROX approximation using DPDK',
1564         'mgmt-interface': {
1565             'vdu-id': 'proxvnf-baremetal',
1566             'host': '1.2.1.1',
1567             'password': 'r00t',
1568             'user': 'root',
1569             'ip': '1.2.1.1',
1570         },
1571         'benchmark': {
1572             'kpi': [
1573                 'packets_in',
1574                 'packets_fwd',
1575                 'packets_dropped',
1576             ],
1577         },
1578         'id': 'ProxApproxVnf',
1579         'name': 'ProxVnf',
1580     }
1581
1582     VNFD = {
1583         'vnfd:vnfd-catalog': {
1584             'vnfd': [
1585                 VNFD0,
1586             ],
1587         },
1588     }
1589
1590     def test_find_pci(self):
1591         input_str_list = [
1592             'no target here',
1593             'nor here',
1594             'and still not',
1595         ]
1596         result = prox_helpers.ProxResourceHelper.find_pci('target',
1597                                                           input_str_list)
1598         self.assertFalse(result)
1599
1600         input_str_list = [
1601             'no target here',
1602             'nor here',
1603             'this is a target',
1604             'did we miss it',
1605         ]
1606         result = prox_helpers.ProxResourceHelper.find_pci('target',
1607                                                           input_str_list)
1608         self.assertTrue(result)
1609
1610     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.RETRY_INTERVAL', 0)
1611     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ProxSocketHelper')
1612     def test_sut(self, *args):
1613         helper = prox_helpers.ProxResourceHelper(mock.MagicMock())
1614         self.assertIsNone(helper.client)
1615         result = helper.sut
1616         self.assertIsNotNone(result)
1617         self.assertIs(result, helper.client)
1618         self.assertIs(result, helper.sut)
1619
1620     def test_test_type(self):
1621         setup_helper = mock.MagicMock()
1622         setup_helper.find_in_section.return_value = expected = 'prox type'
1623
1624         helper = prox_helpers.ProxResourceHelper(setup_helper)
1625
1626         self.assertIsNone(helper._test_type)
1627         self.assertEqual(helper.test_type, expected)
1628         self.assertEqual(helper._test_type, expected)
1629         self.assertEqual(helper.test_type, expected)
1630
1631     def test_collect_collectd_kpi(self):
1632         helper = prox_helpers.ProxResourceHelper(mock.MagicMock())
1633         helper.resource = resource = mock.MagicMock()
1634
1635         resource.check_if_system_agent_running.return_value = 0, '1234'
1636         resource.amqp_collect_nfvi_kpi.return_value = 543
1637         resource.check_if_system_agent_running.return_value = (0, None)
1638
1639         expected = {'core': 543}
1640         result = helper.collect_collectd_kpi()
1641         self.assertDictEqual(result, expected)
1642
1643     def test_collect_kpi(self):
1644         helper = prox_helpers.ProxResourceHelper(mock.MagicMock())
1645         helper._queue = queue = mock.MagicMock()
1646         helper._result = {'z': 123}
1647
1648         helper.client = mock.MagicMock()
1649         helper.client.hz.return_value = 1
1650         helper.client.multi_port_stats.return_value = \
1651             (True, [[0, 1, 2, 3, 4, 5], [1, 1, 2, 3, 4, 5]])
1652         helper.client.multi_port_stats_diff.return_value = \
1653             ([0, 1, 2, 3, 4, 5, 6, 7])
1654         helper.client.multi_port_stats_tuple.return_value = \
1655             {"xe0": {"in_packets": 1, "out_packets": 2}}
1656         helper.resource = resource = mock.MagicMock()
1657
1658         vnfd_helper = mock.MagicMock()
1659         vnfd_helper.ports_iter.return_value = [('xe0', 0), ('xe1', 1)]
1660         helper.vnfd_helper = vnfd_helper
1661
1662         resource.check_if_system_agent_running.return_value = 0, '1234'
1663         resource.amqp_collect_nfvi_kpi.return_value = 543
1664         resource.check_if_system_agent_running.return_value = (0, None)
1665
1666         queue.empty.return_value = False
1667         queue.get.return_value = {'a': 789}
1668
1669         expected = {'z': 123, 'a': 789,
1670                     'collect_stats': {'core': 543},
1671                     'live_stats': {'xe0': {'in_packets': 1, 'out_packets': 2}}}
1672         result = helper.collect_kpi()
1673         self.assertDictEqual(result, expected)
1674
1675     def test_collect_kpi_no_hz(self):
1676         helper = prox_helpers.ProxResourceHelper(mock.MagicMock())
1677         helper._queue = queue = mock.MagicMock()
1678         helper._result = {'z': 123}
1679
1680         helper.client = mock.MagicMock()
1681         helper.client.multi_port_stats.return_value = \
1682             (True, [[0, 1, 2, 3, 4, 5], [1, 1, 2, 3, 4, 5]])
1683         helper.client.multi_port_stats_diff.return_value = \
1684             ([0, 1, 2, 3, 4, 5, 6, 7])
1685         helper.client.multi_port_stats_tuple.return_value = \
1686             {"xe0": {"in_packets": 1, "out_packets": 2}}
1687         helper.resource = resource = mock.MagicMock()
1688
1689         vnfd_helper = mock.MagicMock()
1690         vnfd_helper.ports_iter.return_value = [('xe0', 0), ('xe1', 1)]
1691         helper.vnfd_helper = vnfd_helper
1692
1693         resource.check_if_system_agent_running.return_value = 0, '1234'
1694         resource.amqp_collect_nfvi_kpi.return_value = 543
1695         resource.check_if_system_agent_running.return_value = (0, None)
1696
1697         queue.empty.return_value = False
1698         queue.get.return_value = {'a': 789}
1699
1700         expected = {'z': 123, 'a': 789,
1701                     'collect_stats': {'core': 543},
1702                     'live_stats': {'xe0': {'in_packets': 1, 'out_packets': 2}}}
1703         result = helper.collect_kpi()
1704         self.assertDictEqual(result, expected)
1705
1706     def test_collect_kpi_bad_data(self):
1707         helper = prox_helpers.ProxResourceHelper(mock.MagicMock())
1708         helper._queue = queue = mock.MagicMock()
1709         helper._result = {'z': 123}
1710
1711         helper.client = mock.MagicMock()
1712         helper.client.multi_port_stats.return_value = \
1713             (False, [[0, 1, 2, 3, 4, 5], [1, 1, 2, 3, 4, 5]])
1714         helper.client.multi_port_stats_diff.return_value = \
1715             ([0, 1, 2, 3, 4, 5, 6, 7])
1716         helper.client.multi_port_stats_tuple.return_value = \
1717             {"xe0": {"in_packets": 1, "out_packets": 2}}
1718         helper.resource = resource = mock.MagicMock()
1719
1720         vnfd_helper = mock.MagicMock()
1721         vnfd_helper.ports_iter.return_value = [('xe0', 0), ('xe1', 1)]
1722         helper.vnfd_helper = vnfd_helper
1723
1724         resource.check_if_system_agent_running.return_value = 0, '1234'
1725         resource.amqp_collect_nfvi_kpi.return_value = 543
1726         resource.check_if_system_agent_running.return_value = (0, None)
1727
1728         queue.empty.return_value = False
1729         queue.get.return_value = {'a': 789}
1730
1731         expected = {'z': 123, 'a': 789,
1732                     'collect_stats': {'core': 543}}
1733         result = helper.collect_kpi()
1734         self.assertDictEqual(result, expected)
1735
1736     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
1737     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ProxSocketHelper')
1738     def test__connect(self, mock_socket_helper_type, *args):
1739         client = mock_socket_helper_type()
1740         client.connect.side_effect = chain(repeat(socket.error, 5), [None])
1741
1742         setup_helper = mock.MagicMock()
1743         setup_helper.vnfd_helper.interfaces = []
1744
1745         helper = prox_helpers.ProxResourceHelper(setup_helper)
1746
1747         result = helper._connect()
1748         self.assertIs(result, client)
1749
1750         client.connect.side_effect = chain(repeat(socket.error, 65), [None])
1751
1752         with self.assertRaises(Exception):
1753             helper._connect()
1754
1755     def test_run_traffic(self):
1756         setup_helper = mock.MagicMock()
1757         helper = prox_helpers.ProxResourceHelper(setup_helper)
1758         traffic_profile = mock.MagicMock()
1759         traffic_profile.done.is_set.return_value = True
1760         helper.run_traffic(traffic_profile)
1761         self.assertEqual(helper._terminated.value, 1)
1762
1763     def test__run_traffic_once(self):
1764         setup_helper = mock.MagicMock()
1765         helper = prox_helpers.ProxResourceHelper(setup_helper)
1766         traffic_profile = mock.MagicMock()
1767         traffic_profile.done.is_set.return_value = True
1768         helper._run_traffic_once(traffic_profile)
1769         self.assertEqual(helper._terminated.value, 1)
1770
1771     def test_start_collect(self):
1772         setup_helper = mock.MagicMock()
1773         helper = prox_helpers.ProxResourceHelper(setup_helper)
1774         helper.resource = resource = mock.MagicMock()
1775         self.assertIsNone(helper.start_collect())
1776         resource.start.assert_called_once()
1777
1778     def test_terminate(self):
1779         setup_helper = mock.MagicMock()
1780         helper = prox_helpers.ProxResourceHelper(setup_helper)
1781         with self.assertRaises(NotImplementedError):
1782             helper.terminate()
1783
1784     def test_up_post(self):
1785         setup_helper = mock.MagicMock()
1786         helper = prox_helpers.ProxResourceHelper(setup_helper)
1787         helper.client = expected = mock.MagicMock()
1788         result = helper.up_post()
1789         self.assertEqual(result, expected)
1790
1791     def test_execute(self):
1792         setup_helper = mock.MagicMock()
1793         helper = prox_helpers.ProxResourceHelper(setup_helper)
1794         helper.client = mock.MagicMock()
1795
1796         expected = helper.client.my_command()
1797         result = helper.execute('my_command')
1798         self.assertEqual(result, expected)
1799
1800         # TODO(elfoley): Make this a separate test: test_execute_no_client
1801         helper.client = object()
1802
1803         result = helper.execute('my_command')
1804         self.assertIsNone(result)
1805
1806
1807 class TestProxDataHelper(unittest.TestCase):
1808
1809     def test_totals_and_pps(self):
1810         pkt_size = 180
1811         vnfd_helper = mock.MagicMock()
1812         vnfd_helper.port_pairs.all_ports = list(range(4))
1813
1814         sut = mock.MagicMock()
1815         sut.multi_port_stats.return_value = (True,
1816                                              [[0, 1, 2, 3, 4, 5], [1, 1, 2, 3, 4, 5],
1817                                               [2, 1, 2, 3, 4, 5], [3, 1, 2, 3, 4, 5]])
1818
1819         data_helper = prox_helpers.ProxDataHelper(
1820             vnfd_helper, sut, pkt_size, 25, None,
1821             constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1822
1823         self.assertEqual(data_helper.rx_total, 4)
1824         self.assertEqual(data_helper.tx_total, 8)
1825         self.assertEqual(data_helper.requested_pps, 6250000.0)
1826
1827         vnfd_helper = mock.MagicMock()
1828         vnfd_helper.port_pairs.all_ports = [3, 4]
1829
1830         sut = mock.MagicMock()
1831         sut.multi_port_stats.return_value = (True,
1832                                              [[3, 1, 2, 3, 4, 5], [4, 1, 2, 3, 4, 5]])
1833
1834         data_helper = prox_helpers.ProxDataHelper(
1835             vnfd_helper, sut, pkt_size, 25, None,
1836             constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1837
1838         self.assertEqual(data_helper.rx_total, 2)
1839         self.assertEqual(data_helper.tx_total, 4)
1840         self.assertEqual(data_helper.requested_pps, 3125000.0)
1841
1842         vnfd_helper = mock.MagicMock()
1843         vnfd_helper.port_pairs.all_ports = [0, 1, 2, 3, 4, 6, 7]
1844
1845         sut = mock.MagicMock()
1846         sut.multi_port_stats.return_value = (True,
1847                                              [[8, 1, 2, 3, 4, 5], [9, 1, 2, 3, 4, 5]])
1848
1849         data_helper = prox_helpers.ProxDataHelper(
1850             vnfd_helper, sut, pkt_size, 25, None,
1851             constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1852
1853         self.assertEqual(data_helper.rx_total, 2)
1854         self.assertEqual(data_helper.tx_total, 4)
1855         self.assertEqual(data_helper.requested_pps, 10937500.0)
1856
1857         vnfd_helper = mock.MagicMock()
1858         vnfd_helper.port_pairs.all_ports = []
1859
1860         sut = mock.MagicMock()
1861         sut.multi_port_stats.return_value = (True,
1862                                              [[8, 1, 2, 3, 4, 5], [9, 1, 2, 3, 4, 5]])
1863
1864         data_helper = prox_helpers.ProxDataHelper(
1865             vnfd_helper, sut, pkt_size, 25, None,
1866             constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1867
1868         self.assertEqual(data_helper.rx_total, 2)
1869         self.assertEqual(data_helper.tx_total, 4)
1870         self.assertEqual(data_helper.requested_pps, 0.0)
1871
1872     def test_totals_and_pps2(self):
1873         pkt_size = 180
1874         vnfd_helper = mock.MagicMock()
1875         vnfd_helper.port_pairs.all_ports = list(range(4))
1876
1877         sut = mock.MagicMock()
1878         sut.multi_port_stats.return_value = (True,
1879                                              [[0, 'A', 2, 3, 4, 5], [1, 'B', 'C', 3, 4, 5],
1880                                               ['D', 1, 2, 3, 4, 5], [3, 1, 2, 3, 4, 'F']])
1881
1882         data_helper = prox_helpers.ProxDataHelper(
1883             vnfd_helper, sut, pkt_size, 25, None,
1884             constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1885
1886         self.assertEqual(data_helper.rx_total, 0)
1887         self.assertEqual(data_helper.tx_total, 0)
1888         self.assertEqual(data_helper.requested_pps, 0)
1889
1890     def test_samples(self):
1891         vnfd_helper = mock.MagicMock()
1892         vnfd_helper.ports_iter.return_value = [('xe0', 0), ('xe1', 1)]
1893
1894         sut = mock.MagicMock()
1895         sut.multi_port_stats.return_value = (True, [[0, 1, 2, 3, 4, 5], [1, 11, 12, 3, 4, 5]])
1896
1897         data_helper = prox_helpers.ProxDataHelper(
1898             vnfd_helper, sut, None, None, None, None)
1899
1900         expected = {
1901             'xe0': {
1902                 'in_packets': 1,
1903                 'out_packets': 2,
1904             },
1905             'xe1': {
1906                 'in_packets': 11,
1907                 'out_packets': 12,
1908             },
1909         }
1910         result = data_helper.samples
1911         self.assertDictEqual(result, expected)
1912
1913     def test_samples2(self):
1914         vnfd_helper = mock.MagicMock()
1915         vnfd_helper.ports_iter.return_value = [('xe1', 3), ('xe2', 7)]
1916
1917         sut = mock.MagicMock()
1918         sut.multi_port_stats.return_value = (True, [[3, 1, 2, 3, 4, 5], [7, 11, 12, 3, 4, 5]])
1919
1920         data_helper = prox_helpers.ProxDataHelper(
1921             vnfd_helper, sut, None, None, None, None)
1922
1923         expected = {
1924             'xe1': {
1925                 'in_packets': 1,
1926                 'out_packets': 2,
1927             },
1928             'xe2': {
1929                 'in_packets': 11,
1930                 'out_packets': 12,
1931             },
1932         }
1933         result = data_helper.samples
1934         self.assertDictEqual(result, expected)
1935
1936     def test___enter__(self):
1937         vnfd_helper = mock.MagicMock()
1938         vnfd_helper.port_pairs.all_ports = list(range(4))
1939         vnfd_helper.ports_iter.return_value = [('xe1', 3), ('xe2', 7)]
1940
1941         sut = mock.MagicMock()
1942
1943         data_helper = prox_helpers.ProxDataHelper(vnfd_helper, sut, None, None,
1944             5.4, constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1945         data_helper._totals_and_pps = 12, 32, 4.5
1946         data_helper.tsc_hz = 9.8
1947         data_helper.measured_stats = {
1948             'delta': prox_helpers.TotStatsTuple(6.1, 6.2, 6.3, 6.4)}
1949         data_helper.latency = 7
1950
1951         self.assertIsNone(data_helper.result_tuple)
1952         self.assertEqual(data_helper.line_speed, 10000000000)
1953
1954         expected = prox_helpers.ProxTestDataTuple(
1955             5.4, 9.8, 6.1, 6.2, 6.3, 7, 12, 32, 4.5)
1956         with data_helper:
1957             pass
1958
1959         result = data_helper.result_tuple
1960         self.assertEqual(result, expected)
1961
1962         data_helper.make_tuple()
1963         self.assertIs(data_helper.result_tuple, result)
1964
1965     def test___enter___negative(self):
1966         vnfd_helper = mock.MagicMock()
1967
1968         data_helper = prox_helpers.ProxDataHelper(
1969             vnfd_helper, None, None, None, None, None)
1970
1971         vnfd_helper.port_pairs.all_ports = []
1972         with self.assertRaises(AssertionError):
1973             with data_helper:
1974                 pass
1975
1976         vnfd_helper.port_pairs.all_ports = [0, 1, 2]
1977         with self.assertRaises(AssertionError):
1978             with data_helper:
1979                 pass
1980
1981     def test_measure_tot_stats(self):
1982         vnfd_helper = mock.MagicMock()
1983         vnfd_helper.port_pairs.all_ports = list(range(4))
1984
1985         start = (3, 4, 1, 2)
1986         end = (9, 7, 6, 8)
1987
1988         sut = prox_helpers.ProxSocketHelper(mock.MagicMock())
1989         sut.get_all_tot_stats = mock.MagicMock(side_effect=[start, end])
1990
1991         data_helper = prox_helpers.ProxDataHelper(
1992             vnfd_helper, sut, None, None, 5.4, None)
1993
1994         self.assertIsNone(data_helper.measured_stats)
1995
1996         expected = {
1997             'start_tot': start,
1998             'end_tot': end,
1999             'delta': prox_helpers.TotStatsTuple(6, 3, 5, 6),
2000         }
2001         with data_helper.measure_tot_stats():
2002             pass
2003
2004         self.assertEqual(data_helper.measured_stats, expected)
2005
2006     def test_capture_tsc_hz(self):
2007         vnfd_helper = mock.MagicMock()
2008         vnfd_helper.port_pairs.all_ports = list(range(4))
2009
2010         sut = mock.MagicMock()
2011         sut.hz.return_value = '54.6'
2012
2013         data_helper = prox_helpers.ProxDataHelper(
2014             vnfd_helper, sut, None, None, None, None)
2015
2016         self.assertIsNone(data_helper.tsc_hz)
2017
2018         expected = 54.6
2019         data_helper.capture_tsc_hz()
2020         self.assertEqual(data_helper.tsc_hz, expected)
2021
2022
2023 class TestProxProfileHelper(unittest.TestCase):
2024
2025     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.utils')
2026     def test_get_cls(self, mock_utils):
2027         mock_type1 = mock.MagicMock()
2028         mock_type1.__prox_profile_type__ = 'another_type'
2029         mock_type2 = mock.MagicMock()
2030         mock_type2.__prox_profile_type__ = 'my_type'
2031         mock_utils.itersubclasses.return_value = [mock_type1, mock_type2]
2032
2033         self.assertEqual(prox_helpers.ProxProfileHelper.get_cls('my_type'),
2034                          mock_type2)
2035
2036     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.utils')
2037     def test_get_cls_default(self, mock_utils):
2038         mock_utils.itersubclasses.return_value = []
2039         prox_helpers.ProxProfileHelper.get_cls('my_type')
2040
2041     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.SocketTopology')
2042     def test_cpu_topology(self, mock_socket_topology):
2043         mock_socket_topology.parse_cpuinfo.return_value = 432
2044
2045         resource_helper = mock.MagicMock()
2046         resource_helper.setup_helper.ssh_helper.execute.return_value = 0, 'output', ''
2047
2048         helper = prox_helpers.ProxProfileHelper(resource_helper)
2049         self.assertIsNone(helper._cpu_topology)
2050         result = helper.cpu_topology
2051         self.assertEqual(result, 432)
2052         self.assertIs(result, helper._cpu_topology)
2053         self.assertIs(result, helper.cpu_topology)
2054
2055     # TODO(elfoley): Split this test; there are two sets of inputs/outputs
2056     def test_test_cores(self):
2057         resource_helper = mock.MagicMock()
2058         resource_helper.setup_helper.prox_config_data = []
2059
2060         helper = prox_helpers.ProxProfileHelper(resource_helper)
2061         helper._cpu_topology = []
2062
2063         expected = []
2064         result = helper.test_cores
2065         self.assertEqual(result, expected)
2066
2067         resource_helper.setup_helper.prox_config_data = [
2068             ('section1', []),
2069             ('section2', [
2070                 ('a', 'b'),
2071                 ('c', 'd'),
2072             ]),
2073             ('core 1s3', []),
2074             ('core 2s5', [
2075                 ('index', 8),
2076                 ('mode', ''),
2077             ]),
2078             ('core 3s1', [
2079                 ('index', 5),
2080                 ('mode', 'gen'),
2081             ]),
2082             ('core 4s9h', [
2083                 ('index', 7),
2084                 ('mode', 'gen'),
2085             ]),
2086         ]
2087
2088         helper = prox_helpers.ProxProfileHelper(resource_helper)
2089         helper._cpu_topology = {
2090             1: {
2091                 3: {
2092                     'key1': (23, 32),
2093                     'key2': (12, 21),
2094                     'key3': (44, 33),
2095                 },
2096             },
2097             9: {
2098                 4: {
2099                     'key1': (44, 32),
2100                     'key2': (23, 21),
2101                     'key3': (12, 33),
2102                 },
2103             },
2104         }
2105
2106         self.assertIsNone(helper._test_cores)
2107         expected = [3, 4]
2108         result = helper.test_cores
2109         self.assertEqual(result, expected)
2110         self.assertIs(result, helper._test_cores)
2111         self.assertIs(result, helper.test_cores)
2112
2113     # TODO(elfoley): Split this test; there are two sets of inputs/outputs
2114     def test_latency_cores(self):
2115         resource_helper = mock.MagicMock()
2116         resource_helper.setup_helper.prox_config_data = []
2117
2118         helper = prox_helpers.ProxProfileHelper(resource_helper)
2119         helper._cpu_topology = []
2120
2121         expected = []
2122         result = helper.latency_cores
2123         self.assertEqual(result, expected)
2124
2125         resource_helper.setup_helper.prox_config_data = [
2126             ('section1', []),
2127             ('section2', [
2128                 ('a', 'b'),
2129                 ('c', 'd'),
2130             ]),
2131             ('core 1s3', []),
2132             ('core 2s5', [
2133                 ('index', 8),
2134                 ('mode', ''),
2135             ]),
2136             ('core 3s1', [
2137                 ('index', 5),
2138                 ('mode', 'lat'),
2139             ]),
2140             ('core 4s9h', [
2141                 ('index', 7),
2142                 ('mode', 'lat'),
2143             ]),
2144         ]
2145
2146         helper = prox_helpers.ProxProfileHelper(resource_helper)
2147         helper._cpu_topology = {
2148             1: {
2149                 3: {
2150                     'key1': (23, 32),
2151                     'key2': (12, 21),
2152                     'key3': (44, 33),
2153                 },
2154             },
2155             9: {
2156                 4: {
2157                     'key1': (44, 32),
2158                     'key2': (23, 21),
2159                     'key3': (12, 33),
2160                 },
2161             },
2162         }
2163
2164         self.assertIsNone(helper._latency_cores)
2165         expected = [3, 4]
2166         result = helper.latency_cores
2167         self.assertEqual(result, expected)
2168         self.assertIs(result, helper._latency_cores)
2169         self.assertIs(result, helper.latency_cores)
2170
2171     def test_all_rx_cores(self):
2172         helper = prox_helpers.ProxBngProfileHelper(mock.MagicMock())
2173         helper._latency_cores = expected = [3, 4, 6]
2174         helper._test_cores = [5, 2, 1]
2175
2176         result = helper.all_rx_cores
2177         self.assertEqual(result, expected)
2178
2179     def test_get_cores(self):
2180         resource_helper = mock.MagicMock()
2181         resource_helper.setup_helper.prox_config_data = [
2182             ('section1', []),
2183             ('section2', [
2184                 ('a', 'b'),
2185                 ('c', 'd'),
2186             ]),
2187             ('core 1', []),
2188             ('core 2', [
2189                 ('index', 8),
2190                 ('mode', ''),
2191             ]),
2192             ('core 3', [
2193                 ('index', 5),
2194                 ('mode', 'gen'),
2195             ]),
2196             ('core 4', [
2197                 ('index', 7),
2198                 ('mode', 'gen'),
2199             ]),
2200         ]
2201
2202         helper = prox_helpers.ProxProfileHelper(resource_helper)
2203         helper._cpu_topology = {
2204             0: {
2205                 1: {
2206                     5: (5, 1, 0)
2207                 },
2208                 2: {
2209                     6: (6, 2, 0)
2210                 },
2211                 3: {
2212                     7: (7, 3, 0)
2213                 },
2214                 4: {
2215                     8: (8, 3, 0)
2216                 },
2217             }
2218         }
2219
2220         expected = [3, 4]
2221         result = helper.get_cores(helper.PROX_CORE_GEN_MODE)
2222         self.assertEqual(result, expected)
2223
2224     def test_get_latency(self):
2225         resource_helper = mock.MagicMock()
2226         resource_helper.setup_helper.vnfd_helper.interfaces = []
2227
2228         helper = prox_helpers.ProxProfileHelper(resource_helper)
2229         helper._latency_cores = []
2230
2231         expected = []
2232         result = helper.get_latency()
2233         self.assertEqual(result, expected)
2234
2235         helper._latency_cores = [1, 2]
2236         helper.client = mock.MagicMock()
2237
2238         expected = helper.sut.lat_stats()
2239         result = helper.get_latency()
2240         self.assertIs(result, expected)
2241
2242     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
2243     def test_traffic_context(self, *args):
2244         setup_helper = mock.MagicMock()
2245         setup_helper.vnfd_helper.interfaces = []
2246
2247         helper = prox_helpers.ProxProfileHelper(setup_helper)
2248         helper._cpu_topology = {
2249             0: {
2250                 1: {
2251                     5: (5, 1, 0)
2252                 },
2253                 2: {
2254                     6: (6, 2, 0)
2255                 },
2256                 3: {
2257                     7: (7, 3, 0)
2258                 },
2259                 4: {
2260                     8: (8, 3, 0)
2261                 },
2262             }
2263         }
2264
2265         setup_helper.prox_config_data = [
2266             ('global', [
2267                 ('not_name', 'other data'),
2268                 ('name_not', 'more data'),
2269                 ('name', helper.__prox_profile_type__),
2270             ]),
2271             ('section1', []),
2272             ('section2', [
2273                 ('a', 'b'),
2274                 ('c', 'd'),
2275             ]),
2276             ('core 1', []),
2277             ('core 2', [
2278                 ('index', 8),
2279                 ('mode', ''),
2280             ]),
2281             ('core 3', [
2282                 ('index', 5),
2283                 ('mode', 'gen'),
2284                 ('name', 'tagged'),
2285             ]),
2286             ('core 4', [
2287                 ('index', 7),
2288                 ('mode', 'gen'),
2289                 ('name', 'udp'),
2290             ]),
2291         ]
2292
2293         client = mock.MagicMock()
2294         client.hz.return_value = 2
2295
2296         helper.client = client
2297         helper.get_latency = mock.MagicMock(return_value=[3.3, 3.6, 3.8])
2298
2299         helper._test_cores = [3, 4]
2300
2301         with helper.traffic_context(64, 1):
2302             pass
2303
2304     def test_run_test(self, *args):
2305         resource_helper = mock.MagicMock()
2306         resource_helper.step_delta = 0.4
2307         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2308         resource_helper.sut.multi_port_stats.return_value = (True, [[0, 1, 1, 2, 4, 5],
2309                                                                     [1, 1, 2, 3, 4, 5]])
2310
2311         helper = prox_helpers.ProxProfileHelper(resource_helper)
2312
2313         helper.run_test(pkt_size=120, duration=5, value=6.5, tolerated_loss=0.0,
2314                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2315         self.assertTrue(resource_helper.sut.multi_port_stats.called)
2316         self.assertTrue(resource_helper.sut.stop_all.called)
2317         self.assertTrue(resource_helper.sut.reset_stats.called)
2318
2319 class TestProxMplsProfileHelper(unittest.TestCase):
2320
2321     def test_mpls_cores(self):
2322         resource_helper = mock.MagicMock()
2323         resource_helper.setup_helper.prox_config_data = [
2324             ('section1', []),
2325             ('section2', [
2326                 ('a', 'b'),
2327                 ('c', 'd'),
2328             ]),
2329             ('core 1', []),
2330             ('core 2', [
2331                 ('index', 8),
2332                 ('mode', ''),
2333             ]),
2334             ('core 3', [
2335                 ('index', 5),
2336                 ('mode', 'gen'),
2337                 ('name', 'tagged'),
2338             ]),
2339             ('core 4', [
2340                 ('index', 7),
2341                 ('mode', 'gen'),
2342                 ('name', 'udp'),
2343             ]),
2344         ]
2345
2346         helper = prox_helpers.ProxMplsProfileHelper(resource_helper)
2347         helper._cpu_topology = {
2348             0: {
2349                 1: {
2350                     5: (5, 1, 0)
2351                 },
2352                 2: {
2353                     6: (6, 2, 0)
2354                 },
2355                 3: {
2356                     7: (7, 3, 0)
2357                 },
2358                 4: {
2359                     8: (8, 3, 0)
2360                 },
2361             }
2362         }
2363
2364         expected_tagged = [3]
2365         expected_plain = [4]
2366         self.assertIsNone(helper._cores_tuple)
2367         self.assertEqual(helper.tagged_cores, expected_tagged)
2368         self.assertEqual(helper.plain_cores, expected_plain)
2369         self.assertEqual(helper._cores_tuple, (expected_tagged, expected_plain))
2370
2371     def test_traffic_context(self):
2372         setup_helper = mock.MagicMock()
2373         helper = prox_helpers.ProxMplsProfileHelper(setup_helper)
2374
2375         with helper.traffic_context(120, 5.4):
2376             pass
2377
2378
2379 class TestProxBngProfileHelper(unittest.TestCase):
2380
2381     def test_bng_cores(self):
2382         resource_helper = mock.MagicMock()
2383         resource_helper.setup_helper.prox_config_data = [
2384             ('section1', []),
2385             ('section2', [
2386                 ('a', 'b'),
2387                 ('c', 'd'),
2388             ]),
2389             ('core 1', []),
2390             ('core 2', [
2391                 ('index', 8),
2392                 ('mode', ''),
2393             ]),
2394             ('core 3', [
2395                 ('index', 5),
2396                 ('mode', 'gen'),
2397                 ('name', 'cpe'),
2398             ]),
2399             ('core 4', [
2400                 ('index', 7),
2401                 ('mode', 'gen'),
2402                 ('name', 'inet'),
2403             ]),
2404             ('core 6', [
2405                 ('index', 3),
2406                 ('mode', 'gen'),
2407                 ('name', 'arp_task'),
2408             ]),
2409             ('core 9', [
2410                 ('index', 2),
2411                 ('mode', 'gen'),
2412                 ('name', 'arp'),
2413             ]),
2414         ]
2415
2416         helper = prox_helpers.ProxBngProfileHelper(resource_helper)
2417         helper._cpu_topology = {
2418             0: {
2419                 1: {
2420                     5: (5, 1, 0)
2421                 },
2422                 2: {
2423                     6: (6, 2, 0)
2424                 },
2425                 3: {
2426                     7: (7, 3, 0)
2427                 },
2428                 4: {
2429                     8: (8, 3, 0)
2430                 },
2431                 6: {
2432                     1: (4, 8, 0)
2433                 },
2434                 9: {
2435                     2: (3, 7, 0)
2436                 },
2437             }
2438         }
2439
2440         expected_cpe = [3]
2441         expected_inet = [4]
2442         expected_arp = [6, 9]
2443         expected_arp_task = [0, 6]
2444         expected_combined = (expected_cpe, expected_inet, expected_arp, expected_arp_task)
2445
2446         self.assertIsNone(helper._cores_tuple)
2447         self.assertEqual(helper.cpe_cores, expected_cpe)
2448         self.assertEqual(helper.inet_cores, expected_inet)
2449         self.assertEqual(helper.arp_cores, expected_arp)
2450         self.assertEqual(helper.arp_task_cores, expected_arp_task)
2451         self.assertEqual(helper._cores_tuple, expected_combined)
2452
2453     def test_run_test(self, *args):
2454         resource_helper = mock.MagicMock()
2455         resource_helper.step_delta = 0.4
2456         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2457         resource_helper.sut.multi_port_stats.return_value = (True, [[0, 1, 1, 2, 4, 5],
2458                                                                     [1, 1, 2, 3, 4, 5]])
2459
2460         helper = prox_helpers.ProxBngProfileHelper(resource_helper)
2461
2462         helper.run_test(pkt_size=120, duration=5, value=6.5, tolerated_loss=0.0,
2463                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2464         self.assertTrue(resource_helper.sut.multi_port_stats.called)
2465         self.assertTrue(resource_helper.sut.stop_all.called)
2466         self.assertTrue(resource_helper.sut.reset_stats.called)
2467
2468         resource_helper.reset_mock()
2469
2470         # negative pkt_size is the only way to make ratio > 1
2471         helper.run_test(pkt_size=-1000, duration=5, value=6.5, tolerated_loss=0.0,
2472                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2473
2474         self.assertTrue(resource_helper.sut.multi_port_stats.called)
2475         self.assertTrue(resource_helper.sut.stop_all.called)
2476         self.assertTrue(resource_helper.sut.reset_stats.called)
2477
2478 class TestProxVpeProfileHelper(unittest.TestCase):
2479
2480     def test_vpe_cores(self):
2481         resource_helper = mock.MagicMock()
2482         resource_helper.setup_helper.prox_config_data = [
2483             ('section1', []),
2484             ('section2', [
2485                 ('a', 'b'),
2486                 ('c', 'd'),
2487             ]),
2488             ('core 1', []),
2489             ('core 2', [
2490                 ('index', 8),
2491                 ('mode', ''),
2492             ]),
2493             ('core 3', [
2494                 ('index', 5),
2495                 ('mode', 'gen'),
2496                 ('name', 'cpe'),
2497             ]),
2498             ('core 4', [
2499                 ('index', 7),
2500                 ('mode', 'gen'),
2501                 ('name', 'inet'),
2502             ]),
2503         ]
2504
2505         helper = prox_helpers.ProxVpeProfileHelper(resource_helper)
2506         helper._cpu_topology = {
2507             0: {
2508                 1: {
2509                     5: (5, 1, 0)
2510                 },
2511                 2: {
2512                     6: (6, 2, 0)
2513                 },
2514                 3: {
2515                     7: (7, 3, 0)
2516                 },
2517                 4: {
2518                     8: (8, 3, 0)
2519                 },
2520             }
2521         }
2522
2523         expected_cpe = [3]
2524         expected_inet = [4]
2525         expected_combined = (expected_cpe, expected_inet)
2526
2527         self.assertIsNone(helper._cores_tuple)
2528         self.assertEqual(helper.cpe_cores, expected_cpe)
2529         self.assertEqual(helper.inet_cores, expected_inet)
2530         self.assertEqual(helper._cores_tuple, expected_combined)
2531
2532     def test_vpe_ports(self):
2533         resource_helper = mock.MagicMock()
2534         resource_helper.setup_helper.prox_config_data = [
2535             ('section1', []),
2536             ('section2', [
2537                 ('a', 'b'),
2538                 ('c', 'd'),
2539             ]),
2540             ('port 3', [
2541                 ('index', '5'),
2542                 ('name', 'cpe'),
2543                 ('mac', 'hardware'),
2544             ]),
2545             ('port 4', [
2546                 ('index', '7'),
2547                 ('name', 'inet'),
2548                 ('mac', 'hardware'),
2549             ]),
2550         ]
2551
2552         helper = prox_helpers.ProxVpeProfileHelper(resource_helper)
2553         helper._port_list = {
2554             0: {
2555                 1: {
2556                     5: 'cpe'
2557                 },
2558                 2: {
2559                     6: 'inet'
2560                 },
2561                 3: {
2562                     7: 'cpe'
2563                 },
2564                 4: {
2565                     8: 'inet'
2566                 },
2567             }
2568         }
2569
2570         expected_cpe = [3]
2571         expected_inet = [4]
2572         expected_combined = (expected_cpe, expected_inet)
2573
2574         self.assertIsNone(helper._ports_tuple)
2575         self.assertEqual(helper.cpe_ports, expected_cpe)
2576         self.assertEqual(helper.inet_ports, expected_inet)
2577         self.assertEqual(helper._ports_tuple, expected_combined)
2578
2579     def test_run_test(self, *args):
2580         resource_helper = mock.MagicMock()
2581         resource_helper.step_delta = 0.4
2582         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2583         resource_helper.sut.multi_port_stats.return_value = (True, [[0, 1, 1, 2, 4, 5],
2584                                                                     [1, 1, 2, 3, 4, 5]])
2585
2586         helper = prox_helpers.ProxVpeProfileHelper(resource_helper)
2587
2588         helper.run_test(pkt_size=120, duration=5, value=6.5, tolerated_loss=0.0,
2589                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2590
2591         # negative pkt_size is the only way to make ratio > 1
2592         helper.run_test(pkt_size=-1000, duration=5, value=6.5, tolerated_loss=0.0,
2593                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2594
2595 class TestProxlwAFTRProfileHelper(unittest.TestCase):
2596
2597     def test_lwaftr_cores(self):
2598         resource_helper = mock.MagicMock()
2599         resource_helper.setup_helper.prox_config_data = [
2600             ('section1', []),
2601             ('section2', [
2602                 ('a', 'b'),
2603                 ('c', 'd'),
2604             ]),
2605             ('core 1', []),
2606             ('core 2', [
2607                 ('index', 8),
2608                 ('mode', ''),
2609             ]),
2610             ('core 3', [
2611                 ('index', 5),
2612                 ('mode', 'gen'),
2613                 ('name', 'tun'),
2614             ]),
2615             ('core 4', [
2616                 ('index', 7),
2617                 ('mode', 'gen'),
2618                 ('name', 'inet'),
2619             ]),
2620         ]
2621
2622         helper = prox_helpers.ProxlwAFTRProfileHelper(resource_helper)
2623         helper._cpu_topology = {
2624             0: {
2625                 1: {
2626                     5: (5, 1, 0)
2627                 },
2628                 2: {
2629                     6: (6, 2, 0)
2630                 },
2631                 3: {
2632                     7: (7, 3, 0)
2633                 },
2634                 4: {
2635                     8: (8, 3, 0)
2636                 },
2637             }
2638         }
2639
2640         expected_tun = [3]
2641         expected_inet = [4]
2642         expected_combined = (expected_tun, expected_inet)
2643
2644         self.assertIsNone(helper._cores_tuple)
2645         self.assertEqual(helper.tun_cores, expected_tun)
2646         self.assertEqual(helper.inet_cores, expected_inet)
2647         self.assertEqual(helper._cores_tuple, expected_combined)
2648
2649     def test_tun_ports(self):
2650         resource_helper = mock.MagicMock()
2651         resource_helper.setup_helper.prox_config_data = [
2652             ('section1', []),
2653             ('section2', [
2654                 ('a', 'b'),
2655                 ('c', 'd'),
2656             ]),
2657             ('port 3', [
2658                 ('index', '5'),
2659                 ('name', 'lwB4'),
2660                 ('mac', 'hardware'),
2661             ]),
2662             ('port 4', [
2663                 ('index', '7'),
2664                 ('name', 'inet'),
2665                 ('mac', 'hardware'),
2666             ]),
2667         ]
2668
2669         helper = prox_helpers.ProxlwAFTRProfileHelper(resource_helper)
2670         helper._port_list = {
2671             0: {
2672                 1: {
2673                     5: 'lwB4'
2674                 },
2675                 2: {
2676                     6: 'inet'
2677                 },
2678                 3: {
2679                     7: 'lwB4'
2680                 },
2681                 4: {
2682                     8: 'inet'
2683                 },
2684             }
2685         }
2686
2687         expected_tun = [3]
2688         expected_inet = [4]
2689         expected_combined = (expected_tun, expected_inet)
2690
2691         self.assertIsNone(helper._ports_tuple)
2692         self.assertEqual(helper.tun_ports, expected_tun)
2693         self.assertEqual(helper.inet_ports, expected_inet)
2694         self.assertEqual(helper._ports_tuple, expected_combined)
2695
2696     def test_run_test(self, *args):
2697         resource_helper = mock.MagicMock()
2698         resource_helper.step_delta = 0.4
2699         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2700         resource_helper.sut.multi_port_stats.return_value = (True, [[0, 1, 2, 4, 6, 5],
2701                                                                     [1, 1, 2, 3, 4, 5]])
2702
2703         helper = prox_helpers.ProxlwAFTRProfileHelper(resource_helper)
2704
2705         helper.run_test(pkt_size=120, duration=5, value=6.5, tolerated_loss=0.0,
2706                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2707
2708         # negative pkt_size is the only way to make ratio > 1
2709         helper.run_test(pkt_size=-1000, duration=5, value=6.5, tolerated_loss=0.0,
2710                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)