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_irq_core_stats(self, *args):
 594         mock_socket = mock.MagicMock()
 595         prox = prox_helpers.ProxSocketHelper(mock_socket)
 596         prox.get_data = mock.MagicMock(return_value=('0,1,2,3,4,5,0,1,2,3,4,5,0,1,2,3'))
 597
 598         data_0 = {"cpu": 0, 'bucket_0': 1, 'bucket_1': 2, 'bucket_2': 3, 'bucket_3': 4,
 599                   'bucket_4': 5, 'bucket_5': 0, 'bucket_6': 1, 'bucket_7': 2, 'bucket_8': 3,
 600                   'bucket_9': 4, 'bucket_10': 5, 'bucket_11': 0, 'bucket_12': 1,
 601                   "max_irq": 0, "overflow": 10}
 602
 603         data_1 = {"cpu": 1, 'bucket_0': 1, 'bucket_1': 2, 'bucket_2': 3, 'bucket_3': 4,
 604                   'bucket_4': 5, 'bucket_5': 0, 'bucket_6': 1, 'bucket_7': 2, 'bucket_8': 3,
 605                   'bucket_9': 4, 'bucket_10': 5, 'bucket_11': 0, 'bucket_12': 1,
 606                   "max_irq": 0, "overflow": 10}
 607
 608         expected = {"core_0": data_0, "core_1": data_1}
 609
 610         result = prox.irq_core_stats([[0, 1], [1, 0]])
 611         self.assertDictEqual(result, expected)
 612
 613     @mock.patch.object(prox_helpers.LOG, 'error')
 614     def test_multi_port_stats(self, *args):
 615         mock_socket = mock.MagicMock()
 616         prox = prox_helpers.ProxSocketHelper(mock_socket)
 617         prox.get_string = mock.MagicMock(return_value=(True, '0,1,2,3,4,5;1,1,2,3,4,5'))
 618         expected = [[0, 1, 2, 3, 4, 5], [1, 1, 2, 3, 4, 5]]
 619         status, result = prox.multi_port_stats([0, 1])
 620         self.assertEqual(result, expected)
 621         self.assertEqual(status, True)
 622
 623         prox.get_string = mock.MagicMock(
 624             return_value=(True, '0,1,2,3,4,5;1,1,2,3,4,5'))
 625         status, result = prox.multi_port_stats([0])
 626         self.assertEqual(status, False)
 627
 628         prox.get_string = mock.MagicMock(
 629             return_value=(True, '0,1,2,3,4,5;1,1,2,3,4,5'))
 630         status, result = prox.multi_port_stats([0, 1, 2])
 631         self.assertEqual(status, False)
 632
 633         prox.get_string = mock.MagicMock(
 634             return_value=(True, '0,1,2,3;1,1,2,3,4,5'))
 635         status, result = prox.multi_port_stats([0, 1])
 636         self.assertEqual(status, False)
 637
 638         prox.get_string = mock.MagicMock(
 639             return_value=(True, '99,1,2,3,4,5;1,1,2,3,4,5'))
 640         status, result = prox.multi_port_stats([0, 1])
 641         self.assertEqual(status, False)
 642
 643         prox.get_string = mock.MagicMock(
 644             return_value=(True, '99,1,2,3,4,5;1,1,2,3,4,5'))
 645         status, result = prox.multi_port_stats([99, 1])
 646         expected = [[99, 1, 2, 3, 4, 5], [1, 1, 2, 3, 4, 5]]
 647         self.assertEqual(status, True)
 648         self.assertEqual(result, expected)
 649
 650         prox.get_string = mock.MagicMock(
 651             return_value=(True,
 652                           '2,21,22,23,24,25;1,11,12,13,14,15;0,1,2,3,4,5'))
 653
 654         sample1 = [0, 1, 2, 3, 4, 5]
 655         sample2 = [1, 11, 12, 13, 14, 15]
 656         sample3 = [2, 21, 22, 23, 24, 25]
 657         expected = [sample3, sample2, sample1]
 658         status, result = prox.multi_port_stats([1, 2, 0])
 659         self.assertTrue(status)
 660         self.assertListEqual(result, expected)
 661
 662         prox.get_string = mock.MagicMock(
 663             return_value=(True, '6,21,22,23,24,25;1,11,12,13,14,15;0,1,2,3,4,5'))
 664         ok, result = prox.multi_port_stats([1, 6, 0])
 665         sample1 = [6, 21, 22, 23, 24, 25]
 666         sample2 = [1, 11, 12, 13, 14, 15]
 667         sample3 = [0, 1, 2, 3, 4, 5]
 668         expected = [sample1, sample2, sample3]
 669         self.assertListEqual(result, expected)
 670         self.assertTrue(ok)
 671
 672     @mock.patch.object(prox_helpers.LOG, 'error')
 673     def test_multi_port_stats_diff(self, *args):
 674         mock_socket = mock.MagicMock()
 675         prox = prox_helpers.ProxSocketHelper(mock_socket)
 676         prox.get_string = mock.MagicMock(return_value=(True, '0,1,2,3,4,5;1,1,2,3,4,5'))
 677         _, t1 = prox.multi_port_stats([0, 1])
 678
 679         prox.get_string = mock.MagicMock(return_value=(True, '0,2,4,6,8,6;1,4,8,16,32,6'))
 680         _, t2 = prox.multi_port_stats([0, 1])
 681
 682         prox.get_string = mock.MagicMock(return_value=(True, '0,1,1,1,1,1;1,1,1,1,1,1'))
 683         _, t3 = prox.multi_port_stats([0, 1])
 684
 685         prox.get_string = mock.MagicMock(return_value=(True, '0,2,2,2,2,2;1,2,2,2,2,2'))
 686         _, t4 = prox.multi_port_stats([0, 1])
 687
 688         expected = [[0, 1.0, 2.0, 0, 0, 1], [1, 3.0, 6.0, 0, 0, 1]]
 689         result = prox.multi_port_stats_diff(t1, t2, 1)
 690
 691         self.assertListEqual(result, expected)
 692
 693         result = prox.multi_port_stats_diff(t4, t3, 1)
 694         expected = [[0, 1.0, 1.0, 0, 0, 1], [1, 1.0, 1.0, 0, 0, 1]]
 695
 696         self.assertListEqual(result, expected)
 697
 698         prox.get_string = mock.MagicMock(return_value=(True, '0,2,4,6,8,10'))
 699         ok, t5 = prox.multi_port_stats([0, 1])
 700         self.assertFalse(ok)
 701         self.assertListEqual(t5, [])
 702
 703         result = prox.multi_port_stats_diff(t5, t4, 1)
 704         expected = [[0, 0.0, 0.0, 0, 0, 0], [1, 0.0, 0.0, 0, 0, 0]]
 705         self.assertListEqual(result, expected)
 706
 707         prox.get_string = mock.MagicMock(return_value=(True, '0,10,10,20,30,0;1,30,40,50,60,0'))
 708         _, t6 = prox.multi_port_stats([0, 1])
 709
 710         prox.get_string = \
 711             mock.MagicMock(return_value=(True, '0,100,100,100,100,0;1,100,100,100,100,0'))
 712         _, t7 = prox.multi_port_stats([0, 1])
 713
 714         result = prox.multi_port_stats_diff(t6, t7, 1)
 715         expected = [[0, 0.0, 0.0, 0, 0, 0], [1, 0.0, 0.0, 0, 0, 0]]
 716         self.assertListEqual(result, expected)
 717
 718         result = prox.multi_port_stats_diff(t1, t2, 0)
 719         expected = [[0, 0.0, 0.0, 0, 0, 1], [1, 0.0, 0.0, 0, 0, 1]]
 720         self.assertListEqual(result, expected)
 721
 722     @mock.patch.object(prox_helpers.LOG, 'error')
 723     def test_multi_port_stats_tuple(self, *args):
 724         mock_socket = mock.MagicMock()
 725         prox = prox_helpers.ProxSocketHelper(mock_socket)
 726         prox.get_string = mock.MagicMock(return_value=(True, '0,1,2,3,4,5;1,1,2,3,4,5'))
 727         _, result1 = prox.multi_port_stats([0, 1])
 728         prox.get_string = mock.MagicMock(return_value=(True, '0,2,4,6,8,6;1,4,8,16,32,6'))
 729         _, result2 = prox.multi_port_stats([0, 1])
 730
 731         result = prox.multi_port_stats_diff(result1, result2, 1)
 732
 733         vnfd_helper = mock.MagicMock()
 734         vnfd_helper.ports_iter.return_value = [('xe0', 0), ('xe1', 1)]
 735
 736         expected = {'xe0': {'in_packets': 1.0, 'out_packets': 2.0},
 737                     'xe1': {'in_packets': 3.0, 'out_packets': 6.0}}
 738         live_stats = prox.multi_port_stats_tuple(result, vnfd_helper.ports_iter())
 739         self.assertDictEqual(live_stats, expected)
 740
 741         live_stats = prox.multi_port_stats_tuple(result, None)
 742         expected = {}
 743         self.assertDictEqual(live_stats, expected)
 744
 745         live_stats = prox.multi_port_stats_tuple(None, vnfd_helper.ports_iter())
 746         self.assertDictEqual(live_stats, expected)
 747
 748     def test_port_stats(self):
 749         port_stats = [
 750             ','.join(str(n) for n in range(3, 15)),
 751             ','.join(str(n) for n in range(8, 32, 2)),
 752             ','.join(str(n) for n in range(5, 89, 7)),
 753         ]
 754
 755         mock_socket = mock.MagicMock()
 756         prox = prox_helpers.ProxSocketHelper(mock_socket)
 757         prox.get_data = mock.MagicMock(side_effect=port_stats)
 758         expected = [16, 26, 36, 46, 56, 66, 76, 86, 96, 106, 116, 126]
 759         result = prox.port_stats([3, 4, 5])
 760         self.assertEqual(result, expected)
 761
 762     def test_measure_tot_stats(self):
 763         start_tot = 3, 4, 5, 6
 764         end_tot = 7, 9, 11, 13
 765         delta_tot = 4, 5, 6, 7
 766
 767         get_data_output = [
 768             ','.join(str(n) for n in start_tot),
 769             ','.join(str(n) for n in end_tot),
 770         ]
 771
 772         mock_socket = mock.MagicMock()
 773         prox = prox_helpers.ProxSocketHelper(mock_socket)
 774         prox.get_data = mock.MagicMock(side_effect=get_data_output)
 775         expected = {
 776             'start_tot': start_tot,
 777             'end_tot': end_tot,
 778             'delta': delta_tot,
 779         }
 780         with prox.measure_tot_stats() as result:
 781             pass
 782         self.assertEqual(result, expected)
 783
 784     def test_tot_stats(self):
 785         mock_socket = mock.MagicMock()
 786         prox = prox_helpers.ProxSocketHelper(mock_socket)
 787         prox.get_data = mock.MagicMock(return_value='3,4,5,6')
 788         expected = 3, 4, 5
 789         result = prox.tot_stats()
 790         self.assertEqual(result, expected)
 791
 792     def test_tot_ierrors(self):
 793         mock_socket = mock.MagicMock()
 794         prox = prox_helpers.ProxSocketHelper(mock_socket)
 795         prox.get_data = mock.MagicMock(return_value='3,4,5,6')
 796         expected = 3, 3
 797         result = prox.tot_ierrors()
 798         self.assertEqual(result, expected)
 799
 800     def test_set_count(self):
 801         mock_socket = mock.MagicMock()
 802         prox = prox_helpers.ProxSocketHelper(mock_socket)
 803         prox.set_count(432, [3, 4, 5])
 804         self.assertEqual(mock_socket.sendall.call_count, 3)
 805
 806     def test_dump_rx(self):
 807         mock_socket = mock.MagicMock()
 808         prox = prox_helpers.ProxSocketHelper(mock_socket)
 809         prox.dump_rx(3, 5, 8)
 810         mock_socket.sendall.assert_called_once()
 811
 812     def test_quit(self):
 813         mock_socket = mock.MagicMock()
 814         prox = prox_helpers.ProxSocketHelper(mock_socket)
 815         prox.quit()
 816         mock_socket.sendall.assert_called()
 817
 818     def test_force_quit(self):
 819         mock_socket = mock.MagicMock()
 820         prox = prox_helpers.ProxSocketHelper(mock_socket)
 821         prox.force_quit()
 822         mock_socket.sendall.assert_called()
 823
 824
 825 class TestProxDpdkVnfSetupEnvHelper(unittest.TestCase):
 826
 827     VNFD0 = {
 828         'short-name': 'ProxVnf',
 829         'vdu': [
 830             {
 831                 'routing_table': [
 832                     {
 833                         'network': '152.16.100.20',
 834                         'netmask': '255.255.255.0',
 835                         'gateway': '152.16.100.20',
 836                         'if': 'xe0',
 837                     },
 838                     {
 839                         'network': '152.16.40.20',
 840                         'netmask': '255.255.255.0',
 841                         'gateway': '152.16.40.20',
 842                         'if': 'xe1',
 843                     },
 844                 ],
 845                 'description': 'PROX approximation using DPDK',
 846                 'name': 'proxvnf-baremetal',
 847                 'nd_route_tbl': [
 848                     {
 849                         'network': '0064:ff9b:0:0:0:0:9810:6414',
 850                         'netmask': '112',
 851                         'gateway': '0064:ff9b:0:0:0:0:9810:6414',
 852                         'if': 'xe0',
 853                     },
 854                     {
 855                         'network': '0064:ff9b:0:0:0:0:9810:2814',
 856                         'netmask': '112',
 857                         'gateway': '0064:ff9b:0:0:0:0:9810:2814',
 858                         'if': 'xe1',
 859                     },
 860                 ],
 861                 'id': 'proxvnf-baremetal',
 862                 'external-interface': [
 863                     {
 864                         'virtual-interface': {
 865                             'dst_mac': '00:00:00:00:00:04',
 866                             'vpci': '0000:05:00.0',
 867                             'local_ip': '152.16.100.19',
 868                             'type': 'PCI-PASSTHROUGH',
 869                             'vld_id': 'uplink_0',
 870                             'netmask': '255.255.255.0',
 871                             'dpdk_port_num': 0,
 872                             'bandwidth': '10 Gbps',
 873                             'driver': "i40e",
 874                             'dst_ip': '152.16.100.19',
 875                             'local_iface_name': 'xe0',
 876                             'local_mac': '00:00:00:00:00:02',
 877                             'ifname': 'xe0',
 878                         },
 879                         'vnfd-connection-point-ref': 'xe0',
 880                         'name': 'xe0',
 881                     },
 882                     {
 883                         'virtual-interface': {
 884                             'dst_mac': '00:00:00:00:00:03',
 885                             'vpci': '0000:05:00.1',
 886                             'local_ip': '152.16.40.19',
 887                             'type': 'PCI-PASSTHROUGH',
 888                             'vld_id': 'downlink_0',
 889                             'driver': "i40e",
 890                             'netmask': '255.255.255.0',
 891                             'dpdk_port_num': 1,
 892                             'bandwidth': '10 Gbps',
 893                             'dst_ip': '152.16.40.20',
 894                             'local_iface_name': 'xe1',
 895                             'local_mac': '00:00:00:00:00:01',
 896                             'ifname': 'xe1',
 897                         },
 898                         'vnfd-connection-point-ref': 'xe1',
 899                         'name': 'xe1',
 900                     },
 901                 ],
 902             },
 903         ],
 904         'description': 'PROX approximation using DPDK',
 905         'mgmt-interface': {
 906             'vdu-id': 'proxvnf-baremetal',
 907             'host': '1.2.1.1',
 908             'password': 'r00t',
 909             'user': 'root',
 910             'ip': '1.2.1.1',
 911         },
 912         'benchmark': {
 913             'kpi': [
 914                 'packets_in',
 915                 'packets_fwd',
 916                 'packets_dropped',
 917             ],
 918         },
 919         'id': 'ProxApproxVnf',
 920         'name': 'ProxVnf',
 921     }
 922
 923     VNFD = {
 924         'vnfd:vnfd-catalog': {
 925             'vnfd': [
 926                 VNFD0,
 927             ],
 928         },
 929     }
 930
 931     def test_global_section(self):
 932         setup_helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
 933             mock.MagicMock(), mock.MagicMock(), mock.MagicMock())
 934
 935         setup_helper._prox_config_data = [('a', [])]
 936
 937         with self.assertRaises(KeyError):
 938             _ = setup_helper.global_section
 939
 940         global_section = (
 941             'global', [
 942                 ('not_name', 'other data'),
 943                 ('name_not', 'more data'),
 944                 ('name', 'prox type'),
 945             ],
 946         )
 947
 948         setup_helper._prox_config_data = [
 949             ('section1', []),
 950             ('section2', [
 951                 ('a', 'b'),
 952                 ('c', 'd'),
 953             ]),
 954             ('core 1', []),
 955             ('core 2', [
 956                 ('index', 8),
 957                 ('mode', ''),
 958             ]),
 959             global_section,
 960             ('core 3', [
 961                 ('index', 5),
 962                 ('mode', 'gen'),
 963                 ('name', 'tagged'),
 964             ]),
 965             ('section3', [
 966                 ('key1', 'value1'),
 967                 ('key2', 'value2'),
 968                 ('key3', 'value3'),
 969             ]),
 970             ('core 4', [
 971                 ('index', 7),
 972                 ('mode', 'gen'),
 973                 ('name', 'udp'),
 974             ]),
 975         ]
 976
 977         result = setup_helper.global_section
 978         self.assertEqual(result, global_section[1])
 979
 980     def test_find_in_section(self):
 981         setup_helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
 982             mock.MagicMock(), mock.MagicMock(), mock.MagicMock())
 983
 984         setup_helper._prox_config_data = [
 985             ('global', [
 986                 ('not_name', 'other data'),
 987                 ('name_not', 'more data'),
 988                 ('name', 'prox type'),
 989             ]),
 990             ('section1', []),
 991             ('section2', [
 992                 ('a', 'b'),
 993                 ('c', 'd'),
 994             ]),
 995             ('core 1', []),
 996             ('core 2', [
 997                 ('index', 8),
 998                 ('mode', ''),
 999             ]),
1000             ('core 3', [
1001                 ('index', 5),
1002                 ('mode', 'gen'),
1003                 ('name', 'tagged'),
1004             ]),
1005             ('section3', [
1006                 ('key1', 'value1'),
1007                 ('key2', 'value2'),
1008                 ('key3', 'value3'),
1009             ]),
1010             ('core 4', [
1011                 ('index', 7),
1012                 ('mode', 'gen'),
1013                 ('name', 'udp'),
1014             ]),
1015         ]
1016
1017         expected = 'value3'
1018         result = setup_helper.find_in_section('section3', 'key3')
1019         self.assertEqual(result, expected)
1020
1021         expected = 'default value'
1022         result = setup_helper.find_in_section('section3', 'key4', 'default value')
1023         self.assertEqual(result, expected)
1024
1025         with self.assertRaises(KeyError):
1026             setup_helper.find_in_section('section4', 'key1')
1027
1028         with self.assertRaises(KeyError):
1029             setup_helper.find_in_section('section1', 'key1')
1030
1031     def test__replace_quoted_with_value(self):
1032         # empty string
1033         input_str = ''
1034         expected = ''
1035         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1036                   _replace_quoted_with_value(input_str, 'cat'))
1037         self.assertEqual(result, expected)
1038
1039         # no quoted substring
1040         input_str = 'lion tiger bear'
1041         expected = 'lion tiger bear'
1042         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1043                   _replace_quoted_with_value(input_str, 'cat'))
1044         self.assertEqual(result, expected)
1045
1046         # partially quoted substring
1047         input_str = 'lion "tiger bear'
1048         expected = 'lion "tiger bear'
1049         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1050                   _replace_quoted_with_value(input_str, 'cat'))
1051         self.assertEqual(result, expected)
1052
1053         # one quoted substring
1054         input_str = 'lion "tiger" bear'
1055         expected = 'lion "cat" bear'
1056         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1057                   _replace_quoted_with_value(input_str, 'cat'))
1058         self.assertEqual(result, expected)
1059
1060         # two quoted substrings
1061         input_str = 'lion "tiger" bear "shark" whale'
1062         expected = 'lion "cat" bear "shark" whale'
1063         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1064                   _replace_quoted_with_value(input_str, 'cat'))
1065         self.assertEqual(result, expected)
1066
1067         # two quoted substrings, both replaced
1068         input_str = 'lion "tiger" bear "shark" whale'
1069         expected = 'lion "cat" bear "cat" whale'
1070         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1071                   _replace_quoted_with_value(input_str, 'cat', 2))
1072         self.assertEqual(result, expected)
1073
1074     def test__get_tx_port(self):
1075         # no data
1076         input_data = {'section1': []}
1077         expected = -1
1078         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1079                   _get_tx_port('section1', input_data))
1080         self.assertEqual(result, expected)
1081
1082         # data for other section
1083         input_data = {
1084             'section1': [],
1085             'section2': [
1086                 ('rx port', '3'),
1087                 ('tx port', '4'),
1088             ],
1089         }
1090         expected = -1
1091         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1092                   _get_tx_port('section1', input_data))
1093         self.assertEqual(result, expected)
1094
1095         # data for section
1096         input_data['section1'] = section1 = [
1097             ('rx port', '4', 'more', 432),
1098             ('tx port', '3'),
1099         ]
1100         expected = 3
1101         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1102                   _get_tx_port('section1', input_data))
1103         self.assertEqual(result, expected)
1104
1105         # more data for section,
1106         section1.extend([
1107             ('rx port', '2'),
1108             ('tx port', '1', 'and more', 234),
1109         ])
1110         expected = 1
1111         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1112                   _get_tx_port('section1', input_data))
1113         self.assertEqual(result, expected)
1114
1115     # TODO(elfoley): Split this into several smaller tests
1116     def test_write_prox_config(self):
1117         input_data = {}
1118         expected = ''
1119         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1120                   write_prox_config(input_data))
1121         self.assertEqual(result, expected)
1122
1123         input_data = [
1124             [
1125                 'section1',
1126                 [],
1127             ],
1128         ]
1129         expected = '[section1]'
1130         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1131                   write_prox_config(input_data))
1132         self.assertEqual(result, expected)
1133
1134         input_data = [
1135             [
1136                 'section1',
1137                 [],
1138             ],
1139             [
1140                 'section2',
1141                 [
1142                     ['key1', 'value1'],
1143                     ['__name__', 'not this one'],
1144                     ['key2', None],
1145                     ['key3', 234],
1146                     ['key4', 'multi-line\nvalue'],
1147                 ],
1148             ],
1149         ]
1150         expected = os.linesep.join([
1151             '[section1]',
1152             '[section2]',
1153             'key1=value1',
1154             'key2',
1155             'key3=234',
1156             'key4=multi-line\n\tvalue',
1157         ])
1158         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1159                   write_prox_config(input_data))
1160         self.assertEqual(result, expected)
1161
1162     def test_prox_config_data(self):
1163         setup_helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1164             mock.MagicMock(), mock.MagicMock(), mock.MagicMock())
1165
1166         setup_helper.config_queue = config_queue = mock.MagicMock()
1167         config_queue.get.return_value = expected = [('s', [('a', 3), ('b', 45)])]
1168
1169         result = setup_helper.prox_config_data
1170         self.assertEqual(result, expected)
1171
1172     @mock.patch.object(utils, 'find_relative_file')
1173     def test_build_config_file_no_additional_file(self, mock_find_path):
1174         vnf1 = {
1175             'prox_args': {'-c': ""},
1176             'prox_path': 'd',
1177             'prox_config': 'e/f',
1178             'prox_generate_parameter': False,
1179         }
1180
1181         mock_find_path.side_effect = ['1', '2']
1182
1183         vnfd_helper = mock.MagicMock()
1184         ssh_helper = mock.MagicMock()
1185         scenario_helper = sample_vnf.ScenarioHelper('vnf1')
1186         scenario_helper.scenario_cfg = {
1187             'task_path': 'a/b',
1188             'options': {
1189                 'vnf1': vnf1,
1190             },
1191         }
1192
1193         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1194             vnfd_helper, ssh_helper, scenario_helper)
1195         helper.copy_to_target = mock.MagicMock(return_value='3')
1196         helper.generate_prox_config_file = mock.MagicMock(return_value='4')
1197         helper.upload_prox_config = mock.MagicMock(return_value='5')
1198
1199         self.assertEqual(helper.additional_files, {})
1200         self.assertNotEqual(helper._prox_config_data, '4')
1201         self.assertNotEqual(helper.remote_path, '5')
1202         helper.build_config_file()
1203         self.assertEqual(helper.additional_files, {})
1204         self.assertEqual(helper._prox_config_data, '4')
1205         self.assertEqual(helper.remote_path, '5')
1206
1207     @mock.patch.object(utils, 'find_relative_file')
1208     def test_build_config_file_additional_file_string(self, mock_find_path):
1209         vnf1 = {
1210             'prox_args': {'-c': ""},
1211             'prox_path': 'd',
1212             'prox_config': 'e/f',
1213             'prox_files': 'g/h.i',
1214             'prox_generate_parameter': True,
1215         }
1216
1217         mock_find_path.side_effect = ['1', '2']
1218         vnfd_helper = mock.MagicMock()
1219         ssh_helper = mock.MagicMock()
1220         scenario_helper = sample_vnf.ScenarioHelper('vnf1')
1221         scenario_helper.scenario_cfg = {
1222             'task_path': 'a/b',
1223             'options': {
1224                 'vnf1': vnf1,
1225             },
1226         }
1227
1228         vnfd_helper.port_pairs.all_ports = ['xe0', 'xe1', 'xe2', 'xe3']
1229         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1230             vnfd_helper, ssh_helper, scenario_helper)
1231         helper.copy_to_target = mock.MagicMock(side_effect=['33', '34', '35'])
1232         helper.generate_prox_config_file = mock.MagicMock(return_value='44')
1233         helper.upload_prox_config = mock.MagicMock(return_value='55')
1234
1235         self.assertEqual(helper.additional_files, {})
1236         expected = {'h.i': '33'}
1237         helper.build_config_file()
1238         self.assertDictEqual(helper.additional_files, expected)
1239
1240     @mock.patch.object(utils, 'find_relative_file')
1241     def test_build_config_file_additional_file(self, mock_find_path):
1242         vnf1 = {
1243             'prox_args': {'-c': ""},
1244             'prox_path': 'd',
1245             'prox_config': 'e/f',
1246             'prox_files': [
1247                 'g/h.i',
1248                 'j/k/l',
1249                 'm_n',
1250             ],
1251         }
1252
1253         mock_find_path.side_effect = ['1', '2'] + [str(i) for i in range(len(vnf1['prox_files']))]
1254         vnfd_helper = mock.MagicMock()
1255         ssh_helper = mock.MagicMock()
1256         scenario_helper = sample_vnf.ScenarioHelper('vnf1')
1257         scenario_helper.scenario_cfg = {
1258             'task_path': 'a/b',
1259             'options': {
1260                 'vnf1': vnf1,
1261             },
1262         }
1263
1264         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1265             vnfd_helper, ssh_helper, scenario_helper)
1266         helper.copy_to_target = mock.MagicMock(side_effect=['33', '34', '35'])
1267         helper.generate_prox_config_file = mock.MagicMock(return_value='44')
1268         helper.upload_prox_config = mock.MagicMock(return_value='55')
1269
1270         self.assertEqual(helper.additional_files, {})
1271         self.assertNotEqual(helper._prox_config_data, '44')
1272         self.assertNotEqual(helper.remote_path, '55')
1273         expected = {'h.i': '33', 'l': '34', 'm_n': '35'}
1274         helper.build_config_file()
1275         self.assertDictEqual(helper.additional_files, expected)
1276         self.assertEqual(helper._prox_config_data, '44')
1277         self.assertEqual(helper.remote_path, '55')
1278
1279     def test_build_config(self):
1280         vnf1 = {
1281             'prox_args': {'-f': ""},
1282             'prox_path': '/opt/nsb_bin/prox',
1283             'prox_config': 'configs/gen_l2fwd-2.cfg',
1284             'prox_files': [
1285                 'g/h.i',
1286                 'j/k/l',
1287                 'm_n',
1288             ],
1289         }
1290
1291         vnfd_helper = mock.Mock()
1292         ssh_helper = mock.Mock()
1293         ssh_helper.join_bin_path.return_value = '/opt/nsb_bin/prox'
1294         scenario_helper = sample_vnf.ScenarioHelper('vnf1')
1295         scenario_helper.scenario_cfg = {
1296             'task_path': 'a/b',
1297             'options': {
1298                 'vnf1': vnf1,
1299             },
1300         }
1301
1302         expected = ("sudo bash -c 'cd /opt/nsb_bin; /opt/nsb_bin/prox -o cli "
1303                     "-f  -f /tmp/prox.cfg '")
1304
1305         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1306             vnfd_helper, ssh_helper, scenario_helper)
1307         with mock.patch.object(helper, 'build_config_file') as mock_cfg_file:
1308             helper.remote_path = '/tmp/prox.cfg'
1309             prox_cmd = helper.build_config()
1310             self.assertEqual(prox_cmd, expected)
1311             mock_cfg_file.assert_called_once()
1312
1313     def test__insert_additional_file(self):
1314         vnfd_helper = mock.MagicMock()
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 = {"ipv4.lua": "/tmp/ipv4.lua"}
1321         res = helper._insert_additional_file('dofile("ipv4.lua")')
1322         self.assertEqual(res, 'dofile("/tmp/ipv4.lua")')
1323
1324     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ConfigParser')
1325     def test_generate_prox_config_file(self, mock_parser_type):
1326         def init(*args):
1327             if sections_data:
1328                 args[-1].extend(sections_data)
1329             return mock.MagicMock()
1330
1331         sections_data = []
1332
1333         mock_parser_type.side_effect = init
1334
1335         vnfd_helper = vnf_base.VnfdHelper(self.VNFD0)
1336         ssh_helper = mock.MagicMock()
1337         scenario_helper = mock.MagicMock()
1338
1339         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1340             vnfd_helper, ssh_helper, scenario_helper)
1341         helper.additional_files = {}
1342
1343         expected = []
1344         result = helper.generate_prox_config_file('a/b')
1345         self.assertEqual(result, expected)
1346
1347         helper.additional_files = {"ipv4.lua": "/tmp/ipv4.lua"}
1348
1349         helper.remote_prox_file_name = 'remote'
1350         sections_data = [
1351             [
1352                 'lua',
1353                 [
1354                     ['dofile("ipv4.lua")', ''],
1355                 ],
1356             ],
1357             [
1358                 'port 0',
1359                 [
1360                     ['ip', ''],
1361                     ['mac', 'foo'],
1362                     ['dst mac', '@@1'],
1363                     ['tx port', '1'],
1364                 ],
1365             ],
1366             [
1367                 'port 2',
1368                 [
1369                     ['ip', ''],
1370                     ['$sut_mac0', '@@dst_mac0'],
1371                     ['tx port', '0'],
1372                     ['single', '@'],
1373                     ['user_table', 'dofile("ipv4.lua")'],
1374                     ['missing_addtional_file', 'dofile("nosuch")'],
1375                 ],
1376             ],
1377             [
1378                 'core 0',
1379                 [
1380                     ['name', 'p0']
1381                 ]
1382             ],
1383             [
1384                 'core 1-4',
1385                 [
1386                     ['name', 'p1']
1387                 ]
1388             ],
1389             [
1390                 'core 5,6',
1391                 [
1392                     ['name', 'p2']
1393                 ]
1394             ],
1395             [
1396                 'core xx',
1397                 [
1398                     ['name', 'p3']
1399                 ]
1400             ],
1401             [
1402                 'core $x',
1403                 [
1404                     ['name', 'p4']
1405                 ]
1406             ]
1407         ]
1408
1409         expected = [
1410             [
1411                 'lua',
1412                 [
1413                     ['dofile("/tmp/ipv4.lua")', ''],
1414                 ],
1415             ],
1416             [
1417                 'port 0',
1418                 [
1419                     ['ip', ''],
1420                     ['mac', 'hardware'],
1421                     ['dst mac', '00:00:00:00:00:03'],
1422                     ['tx port', '1'],
1423                 ],
1424             ],
1425             [
1426                 'port 2',
1427                 [
1428                     ['ip', ''],
1429                     ['$sut_mac0', '00 00 00 00 00 04'],
1430                     ['tx port', '0'],
1431                     ['single', '@'],
1432                     ['user_table', 'dofile("/tmp/ipv4.lua")'],
1433                     ['missing_addtional_file', 'dofile("nosuch")'],
1434                 ],
1435             ],
1436             [
1437                 'core 0',
1438                 [
1439                     ['name', 'p0']
1440                 ]
1441             ],
1442             [
1443                 'core 1',
1444                 [
1445                     ['name', 'p1']
1446                 ]
1447             ],
1448             [
1449                 'core 2',
1450                 [
1451                     ['name', 'p1']
1452                 ]
1453             ],
1454             [
1455                 'core 3',
1456                 [
1457                     ['name', 'p1']
1458                 ]
1459             ],
1460             [
1461                 'core 4',
1462                 [
1463                     ['name', 'p1']
1464                 ]
1465             ],
1466             [
1467                 'core 5',
1468                 [
1469                     ['name', 'p2']
1470                 ]
1471             ],
1472             [
1473                 'core 6',
1474                 [
1475                     ['name', 'p2']
1476                 ]
1477             ],
1478             [
1479                 'core $x',
1480                 [
1481                     ['name', 'p4']
1482                 ]
1483             ]
1484         ]
1485         result = helper.generate_prox_config_file('/c/d/e')
1486         self.assertEqual(result, expected, str(result))
1487
1488     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ConfigParser')
1489     def test_generate_prox_config_file_negative(self, mock_parser_type):
1490         def init(*args):
1491             args[-1].update(sections_data)
1492             return mock.MagicMock()
1493
1494         sections_data = {}
1495
1496         mock_parser_type.side_effect = init
1497
1498         vnfd_helper = mock.MagicMock()
1499         vnfd_helper.interfaces = []
1500         ssh_helper = mock.MagicMock()
1501         scenario_helper = mock.MagicMock()
1502
1503         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1504             vnfd_helper, ssh_helper, scenario_helper)
1505         helper.additional_files = {}
1506         helper.remote_prox_file_name = 'remote'
1507         vnfd_helper.interfaces = [
1508             {
1509                 'virtual-interface': {
1510                     'dpdk_port_num': 3,
1511                     'dst_mac': '00:00:00:de:ad:88',
1512                 },
1513             },
1514             {
1515                 'virtual-interface': {
1516                     'dpdk_port_num': 5,
1517                     'dst_mac': '00:00:00:de:ad:ff',
1518                 },
1519             },
1520             {
1521                 'virtual-interface': {
1522                     'dpdk_port_num': 7,
1523                     'dst_mac': '00:00:00:de:ad:ff',
1524                 },
1525             },
1526         ]
1527         sections_data = {
1528             'port 3': [
1529                 ['ip', ''],
1530                 ['mac', 'foo'],
1531                 ['dst mac', ''],
1532             ],
1533             'port 5': [
1534                 ['ip', ''],
1535                 ['dst mac', ''],
1536                 ['tx port', '0'],
1537                 ['???', 'dofile "here" 23'],
1538             ],
1539         }
1540
1541         with self.assertRaises(Exception):
1542             helper.generate_prox_config_file('a/b')
1543
1544     def test_put_string_to_file(self):
1545         vnfd_helper = mock.MagicMock()
1546         vnfd_helper.interfaces = []
1547         ssh_helper = mock.MagicMock()
1548         scenario_helper = mock.MagicMock()
1549
1550         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1551             vnfd_helper, ssh_helper, scenario_helper)
1552
1553         expected = 'a/b'
1554         result = helper.put_string_to_file('my long string', 'a/b')
1555         self.assertEqual(result, expected)
1556
1557     def test_copy_to_target(self):
1558         vnfd_helper = mock.MagicMock()
1559         vnfd_helper.interfaces = []
1560         ssh_helper = mock.MagicMock()
1561         scenario_helper = mock.MagicMock()
1562
1563         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1564             vnfd_helper, ssh_helper, scenario_helper)
1565         expected = '/tmp/c'
1566         result = helper.copy_to_target('a/b', 'c')
1567         self.assertEqual(result, expected)
1568
1569     def test_upload_prox_config(self):
1570         vnfd_helper = mock.MagicMock()
1571         vnfd_helper.interfaces = []
1572         ssh_helper = mock.MagicMock()
1573         scenario_helper = mock.MagicMock()
1574
1575         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1576             vnfd_helper, ssh_helper, scenario_helper)
1577         helper.write_prox_config = mock.MagicMock(return_value='a long string')
1578         expected = '/tmp/a'
1579         result = helper.upload_prox_config('a', {})
1580         self.assertEqual(result, expected)
1581
1582
1583 class TestProxResourceHelper(unittest.TestCase):
1584
1585     VNFD0 = {
1586         'short-name': 'ProxVnf',
1587         'vdu': [
1588             {
1589                 'routing_table': [
1590                     {
1591                         'network': '152.16.100.20',
1592                         'netmask': '255.255.255.0',
1593                         'gateway': '152.16.100.20',
1594                         'if': 'xe0',
1595                     },
1596                     {
1597                         'network': '152.16.40.20',
1598                         'netmask': '255.255.255.0',
1599                         'gateway': '152.16.40.20',
1600                         'if': 'xe1',
1601                     },
1602                 ],
1603                 'description': 'PROX approximation using DPDK',
1604                 'name': 'proxvnf-baremetal',
1605                 'nd_route_tbl': [
1606                     {
1607                         'network': '0064:ff9b:0:0:0:0:9810:6414',
1608                         'netmask': '112',
1609                         'gateway': '0064:ff9b:0:0:0:0:9810:6414',
1610                         'if': 'xe0',
1611                     },
1612                     {
1613                         'network': '0064:ff9b:0:0:0:0:9810:2814',
1614                         'netmask': '112',
1615                         'gateway': '0064:ff9b:0:0:0:0:9810:2814',
1616                         'if': 'xe1',
1617                     },
1618                 ],
1619                 'id': 'proxvnf-baremetal',
1620                 'external-interface': [
1621                     {
1622                         'virtual-interface': {
1623                             'dst_mac': '00:00:00:00:00:04',
1624                             'vpci': '0000:05:00.0',
1625                             'local_ip': '152.16.100.19',
1626                             'type': 'PCI-PASSTHROUGH',
1627                             'vld_id': 'uplink_0',
1628                             'netmask': '255.255.255.0',
1629                             'dpdk_port_num': 0,
1630                             'bandwidth': '10 Gbps',
1631                             'driver': "i40e",
1632                             'dst_ip': '152.16.100.19',
1633                             'local_iface_name': 'xe0',
1634                             'local_mac': '00:00:00:00:00:02',
1635                             'ifname': 'xe0',
1636                         },
1637                         'vnfd-connection-point-ref': 'xe0',
1638                         'name': 'xe0',
1639                     },
1640                     {
1641                         'virtual-interface': {
1642                             'dst_mac': '00:00:00:00:00:03',
1643                             'vpci': '0000:05:00.1',
1644                             'local_ip': '152.16.40.19',
1645                             'type': 'PCI-PASSTHROUGH',
1646                             'vld_id': 'downlink_0',
1647                             'driver': "i40e",
1648                             'netmask': '255.255.255.0',
1649                             'dpdk_port_num': 1,
1650                             'bandwidth': '10 Gbps',
1651                             'dst_ip': '152.16.40.20',
1652                             'local_iface_name': 'xe1',
1653                             'local_mac': '00:00:00:00:00:01',
1654                             'ifname': 'xe1',
1655                         },
1656                         'vnfd-connection-point-ref': 'xe1',
1657                         'name': 'xe1',
1658                     },
1659                 ],
1660             },
1661         ],
1662         'description': 'PROX approximation using DPDK',
1663         'mgmt-interface': {
1664             'vdu-id': 'proxvnf-baremetal',
1665             'host': '1.2.1.1',
1666             'password': 'r00t',
1667             'user': 'root',
1668             'ip': '1.2.1.1',
1669         },
1670         'benchmark': {
1671             'kpi': [
1672                 'packets_in',
1673                 'packets_fwd',
1674                 'packets_dropped',
1675             ],
1676         },
1677         'id': 'ProxApproxVnf',
1678         'name': 'ProxVnf',
1679     }
1680
1681     VNFD = {
1682         'vnfd:vnfd-catalog': {
1683             'vnfd': [
1684                 VNFD0,
1685             ],
1686         },
1687     }
1688
1689     def test_find_pci(self):
1690         input_str_list = [
1691             'no target here',
1692             'nor here',
1693             'and still not',
1694         ]
1695         result = prox_helpers.ProxResourceHelper.find_pci('target',
1696                                                           input_str_list)
1697         self.assertFalse(result)
1698
1699         input_str_list = [
1700             'no target here',
1701             'nor here',
1702             'this is a target',
1703             'did we miss it',
1704         ]
1705         result = prox_helpers.ProxResourceHelper.find_pci('target',
1706                                                           input_str_list)
1707         self.assertTrue(result)
1708
1709     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.RETRY_INTERVAL', 0)
1710     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ProxSocketHelper')
1711     def test_sut(self, *args):
1712         helper = prox_helpers.ProxResourceHelper(mock.MagicMock())
1713         self.assertIsNone(helper.client)
1714         result = helper.sut
1715         self.assertIsNotNone(result)
1716         self.assertIs(result, helper.client)
1717         self.assertIs(result, helper.sut)
1718
1719     def test_test_type(self):
1720         setup_helper = mock.MagicMock()
1721         setup_helper.find_in_section.return_value = expected = 'prox type'
1722
1723         helper = prox_helpers.ProxResourceHelper(setup_helper)
1724
1725         self.assertIsNone(helper._test_type)
1726         self.assertEqual(helper.test_type, expected)
1727         self.assertEqual(helper._test_type, expected)
1728         self.assertEqual(helper.test_type, expected)
1729
1730     def test_collect_collectd_kpi(self):
1731         helper = prox_helpers.ProxResourceHelper(mock.MagicMock())
1732         helper.resource = resource = mock.MagicMock()
1733
1734         resource.check_if_system_agent_running.return_value = 0, '1234'
1735         resource.amqp_collect_nfvi_kpi.return_value = 543
1736         resource.check_if_system_agent_running.return_value = (0, None)
1737
1738         expected = {'core': 543}
1739         result = helper.collect_collectd_kpi()
1740         self.assertDictEqual(result, expected)
1741
1742     def test_collect_kpi(self):
1743         helper = prox_helpers.ProxResourceHelper(mock.MagicMock())
1744         helper._queue = queue = mock.MagicMock()
1745         helper._result = {'z': 123}
1746
1747         helper.client = mock.MagicMock()
1748         helper.client.hz.return_value = 1
1749         helper.client.multi_port_stats.return_value = \
1750             (True, [[0, 1, 2, 3, 4, 5], [1, 1, 2, 3, 4, 5]])
1751         helper.client.multi_port_stats_diff.return_value = \
1752             ([0, 1, 2, 3, 4, 5, 6, 7])
1753         helper.client.multi_port_stats_tuple.return_value = \
1754             {"xe0": {"in_packets": 1, "out_packets": 2}}
1755         helper.resource = resource = mock.MagicMock()
1756
1757         vnfd_helper = mock.MagicMock()
1758         vnfd_helper.ports_iter.return_value = [('xe0', 0), ('xe1', 1)]
1759         helper.vnfd_helper = vnfd_helper
1760
1761         resource.check_if_system_agent_running.return_value = 0, '1234'
1762         resource.amqp_collect_nfvi_kpi.return_value = 543
1763         resource.check_if_system_agent_running.return_value = (0, None)
1764
1765         queue.empty.return_value = False
1766         queue.get.return_value = {'a': 789}
1767
1768         expected = {'z': 123, 'a': 789,
1769                     'collect_stats': {'core': 543},
1770                     'live_stats': {'xe0': {'in_packets': 1, 'out_packets': 2}}}
1771         result = helper.collect_kpi()
1772         self.assertDictEqual(result, expected)
1773
1774     def test_collect_kpi_no_hz(self):
1775         helper = prox_helpers.ProxResourceHelper(mock.MagicMock())
1776         helper._queue = queue = mock.MagicMock()
1777         helper._result = {'z': 123}
1778
1779         helper.client = mock.MagicMock()
1780         helper.client.multi_port_stats.return_value = \
1781             (True, [[0, 1, 2, 3, 4, 5], [1, 1, 2, 3, 4, 5]])
1782         helper.client.multi_port_stats_diff.return_value = \
1783             ([0, 1, 2, 3, 4, 5, 6, 7])
1784         helper.client.multi_port_stats_tuple.return_value = \
1785             {"xe0": {"in_packets": 1, "out_packets": 2}}
1786         helper.resource = resource = mock.MagicMock()
1787
1788         vnfd_helper = mock.MagicMock()
1789         vnfd_helper.ports_iter.return_value = [('xe0', 0), ('xe1', 1)]
1790         helper.vnfd_helper = vnfd_helper
1791
1792         resource.check_if_system_agent_running.return_value = 0, '1234'
1793         resource.amqp_collect_nfvi_kpi.return_value = 543
1794         resource.check_if_system_agent_running.return_value = (0, None)
1795
1796         queue.empty.return_value = False
1797         queue.get.return_value = {'a': 789}
1798
1799         expected = {'z': 123, 'a': 789,
1800                     'collect_stats': {'core': 543},
1801                     'live_stats': {'xe0': {'in_packets': 1, 'out_packets': 2}}}
1802         result = helper.collect_kpi()
1803         self.assertDictEqual(result, expected)
1804
1805     def test_collect_kpi_bad_data(self):
1806         helper = prox_helpers.ProxResourceHelper(mock.MagicMock())
1807         helper._queue = queue = mock.MagicMock()
1808         helper._result = {'z': 123}
1809
1810         helper.client = mock.MagicMock()
1811         helper.client.multi_port_stats.return_value = \
1812             (False, [[0, 1, 2, 3, 4, 5], [1, 1, 2, 3, 4, 5]])
1813         helper.client.multi_port_stats_diff.return_value = \
1814             ([0, 1, 2, 3, 4, 5, 6, 7])
1815         helper.client.multi_port_stats_tuple.return_value = \
1816             {"xe0": {"in_packets": 1, "out_packets": 2}}
1817         helper.resource = resource = mock.MagicMock()
1818
1819         vnfd_helper = mock.MagicMock()
1820         vnfd_helper.ports_iter.return_value = [('xe0', 0), ('xe1', 1)]
1821         helper.vnfd_helper = vnfd_helper
1822
1823         resource.check_if_system_agent_running.return_value = 0, '1234'
1824         resource.amqp_collect_nfvi_kpi.return_value = 543
1825         resource.check_if_system_agent_running.return_value = (0, None)
1826
1827         queue.empty.return_value = False
1828         queue.get.return_value = {'a': 789}
1829
1830         expected = {'z': 123, 'a': 789,
1831                     'collect_stats': {'core': 543}}
1832         result = helper.collect_kpi()
1833         self.assertDictEqual(result, expected)
1834
1835     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
1836     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ProxSocketHelper')
1837     def test__connect(self, mock_socket_helper_type, *args):
1838         client = mock_socket_helper_type()
1839         client.connect.side_effect = chain(repeat(socket.error, 5), [None])
1840
1841         setup_helper = mock.MagicMock()
1842         setup_helper.vnfd_helper.interfaces = []
1843
1844         helper = prox_helpers.ProxResourceHelper(setup_helper)
1845
1846         result = helper._connect()
1847         self.assertIs(result, client)
1848
1849         client.connect.side_effect = chain(repeat(socket.error, 65), [None])
1850
1851         with self.assertRaises(Exception):
1852             helper._connect()
1853
1854     def test_run_traffic(self):
1855         setup_helper = mock.MagicMock()
1856         helper = prox_helpers.ProxResourceHelper(setup_helper)
1857         traffic_profile = mock.MagicMock()
1858         traffic_profile.done.is_set.return_value = True
1859         helper.run_traffic(traffic_profile)
1860         self.assertEqual(helper._terminated.value, 1)
1861
1862     def test__run_traffic_once(self):
1863         setup_helper = mock.MagicMock()
1864         helper = prox_helpers.ProxResourceHelper(setup_helper)
1865         traffic_profile = mock.MagicMock()
1866         traffic_profile.done.is_set.return_value = True
1867         helper._run_traffic_once(traffic_profile)
1868         self.assertEqual(helper._terminated.value, 1)
1869
1870     def test_start_collect(self):
1871         setup_helper = mock.MagicMock()
1872         helper = prox_helpers.ProxResourceHelper(setup_helper)
1873         helper.resource = resource = mock.MagicMock()
1874         self.assertIsNone(helper.start_collect())
1875         resource.start.assert_called_once()
1876
1877     def test_terminate(self):
1878         setup_helper = mock.MagicMock()
1879         helper = prox_helpers.ProxResourceHelper(setup_helper)
1880         with self.assertRaises(NotImplementedError):
1881             helper.terminate()
1882
1883     def test_up_post(self):
1884         setup_helper = mock.MagicMock()
1885         helper = prox_helpers.ProxResourceHelper(setup_helper)
1886         helper.client = expected = mock.MagicMock()
1887         result = helper.up_post()
1888         self.assertEqual(result, expected)
1889
1890     def test_execute(self):
1891         setup_helper = mock.MagicMock()
1892         helper = prox_helpers.ProxResourceHelper(setup_helper)
1893         helper.client = mock.MagicMock()
1894
1895         expected = helper.client.my_command()
1896         result = helper.execute('my_command')
1897         self.assertEqual(result, expected)
1898
1899         # TODO(elfoley): Make this a separate test: test_execute_no_client
1900         helper.client = object()
1901
1902         result = helper.execute('my_command')
1903         self.assertIsNone(result)
1904
1905
1906 class TestProxDataHelper(unittest.TestCase):
1907
1908     def test_totals_and_pps(self):
1909         pkt_size = 180
1910         vnfd_helper = mock.MagicMock()
1911         vnfd_helper.port_pairs.all_ports = list(range(4))
1912
1913         sut = mock.MagicMock()
1914         sut.multi_port_stats.return_value = (True,
1915                                              [[0, 1, 2, 3, 4, 5], [1, 1, 2, 3, 4, 5],
1916                                               [2, 1, 2, 3, 4, 5], [3, 1, 2, 3, 4, 5]])
1917
1918         data_helper = prox_helpers.ProxDataHelper(
1919             vnfd_helper, sut, pkt_size, 25, None,
1920             constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1921
1922         self.assertEqual(data_helper.rx_total, 4)
1923         self.assertEqual(data_helper.tx_total, 8)
1924         self.assertEqual(data_helper.requested_pps, 6250000.0)
1925
1926         vnfd_helper = mock.MagicMock()
1927         vnfd_helper.port_pairs.all_ports = [3, 4]
1928
1929         sut = mock.MagicMock()
1930         sut.multi_port_stats.return_value = (True,
1931                                              [[3, 1, 2, 3, 4, 5], [4, 1, 2, 3, 4, 5]])
1932
1933         data_helper = prox_helpers.ProxDataHelper(
1934             vnfd_helper, sut, pkt_size, 25, None,
1935             constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1936
1937         self.assertEqual(data_helper.rx_total, 2)
1938         self.assertEqual(data_helper.tx_total, 4)
1939         self.assertEqual(data_helper.requested_pps, 3125000.0)
1940
1941         vnfd_helper = mock.MagicMock()
1942         vnfd_helper.port_pairs.all_ports = [0, 1, 2, 3, 4, 6, 7]
1943
1944         sut = mock.MagicMock()
1945         sut.multi_port_stats.return_value = (True,
1946                                              [[8, 1, 2, 3, 4, 5], [9, 1, 2, 3, 4, 5]])
1947
1948         data_helper = prox_helpers.ProxDataHelper(
1949             vnfd_helper, sut, pkt_size, 25, None,
1950             constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1951
1952         self.assertEqual(data_helper.rx_total, 2)
1953         self.assertEqual(data_helper.tx_total, 4)
1954         self.assertEqual(data_helper.requested_pps, 10937500.0)
1955
1956         vnfd_helper = mock.MagicMock()
1957         vnfd_helper.port_pairs.all_ports = []
1958
1959         sut = mock.MagicMock()
1960         sut.multi_port_stats.return_value = (True,
1961                                              [[8, 1, 2, 3, 4, 5], [9, 1, 2, 3, 4, 5]])
1962
1963         data_helper = prox_helpers.ProxDataHelper(
1964             vnfd_helper, sut, pkt_size, 25, None,
1965             constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1966
1967         self.assertEqual(data_helper.rx_total, 2)
1968         self.assertEqual(data_helper.tx_total, 4)
1969         self.assertEqual(data_helper.requested_pps, 0.0)
1970
1971     def test_totals_and_pps2(self):
1972         pkt_size = 180
1973         vnfd_helper = mock.MagicMock()
1974         vnfd_helper.port_pairs.all_ports = list(range(4))
1975
1976         sut = mock.MagicMock()
1977         sut.multi_port_stats.return_value = (True,
1978                                              [[0, 'A', 2, 3, 4, 5], [1, 'B', 'C', 3, 4, 5],
1979                                               ['D', 1, 2, 3, 4, 5], [3, 1, 2, 3, 4, 'F']])
1980
1981         data_helper = prox_helpers.ProxDataHelper(
1982             vnfd_helper, sut, pkt_size, 25, None,
1983             constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1984
1985         self.assertEqual(data_helper.rx_total, 0)
1986         self.assertEqual(data_helper.tx_total, 0)
1987         self.assertEqual(data_helper.requested_pps, 0)
1988
1989     def test_samples(self):
1990         vnfd_helper = mock.MagicMock()
1991         vnfd_helper.ports_iter.return_value = [('xe0', 0), ('xe1', 1)]
1992
1993         sut = mock.MagicMock()
1994         sut.multi_port_stats.return_value = (True, [[0, 1, 2, 3, 4, 5], [1, 11, 12, 3, 4, 5]])
1995
1996         data_helper = prox_helpers.ProxDataHelper(
1997             vnfd_helper, sut, None, None, None, None)
1998
1999         expected = {
2000             'xe0': {
2001                 'in_packets': 1,
2002                 'out_packets': 2,
2003             },
2004             'xe1': {
2005                 'in_packets': 11,
2006                 'out_packets': 12,
2007             },
2008         }
2009         result = data_helper.samples
2010         self.assertDictEqual(result, expected)
2011
2012     def test_samples2(self):
2013         vnfd_helper = mock.MagicMock()
2014         vnfd_helper.ports_iter.return_value = [('xe1', 3), ('xe2', 7)]
2015
2016         sut = mock.MagicMock()
2017         sut.multi_port_stats.return_value = (True, [[3, 1, 2, 3, 4, 5], [7, 11, 12, 3, 4, 5]])
2018
2019         data_helper = prox_helpers.ProxDataHelper(
2020             vnfd_helper, sut, None, None, None, None)
2021
2022         expected = {
2023             'xe1': {
2024                 'in_packets': 1,
2025                 'out_packets': 2,
2026             },
2027             'xe2': {
2028                 'in_packets': 11,
2029                 'out_packets': 12,
2030             },
2031         }
2032         result = data_helper.samples
2033         self.assertDictEqual(result, expected)
2034
2035     def test___enter__(self):
2036         vnfd_helper = mock.MagicMock()
2037         vnfd_helper.port_pairs.all_ports = list(range(4))
2038         vnfd_helper.ports_iter.return_value = [('xe1', 3), ('xe2', 7)]
2039
2040         sut = mock.MagicMock()
2041
2042         data_helper = prox_helpers.ProxDataHelper(vnfd_helper, sut, None, None,
2043             5.4, constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2044         data_helper._totals_and_pps = 12, 32, 4.5
2045         data_helper.tsc_hz = 9.8
2046         data_helper.measured_stats = {
2047             'delta': prox_helpers.TotStatsTuple(6.1, 6.2, 6.3, 6.4)}
2048         data_helper.latency = 7
2049
2050         self.assertIsNone(data_helper.result_tuple)
2051         self.assertEqual(data_helper.line_speed, 10000000000)
2052
2053         expected = prox_helpers.ProxTestDataTuple(
2054             5.4, 9.8, 6.1, 6.2, 6.3, 7, 12, 32, 4.5)
2055         with data_helper:
2056             pass
2057
2058         result = data_helper.result_tuple
2059         self.assertEqual(result, expected)
2060
2061         data_helper.make_tuple()
2062         self.assertIs(data_helper.result_tuple, result)
2063
2064     def test___enter___negative(self):
2065         vnfd_helper = mock.MagicMock()
2066
2067         data_helper = prox_helpers.ProxDataHelper(
2068             vnfd_helper, None, None, None, None, None)
2069
2070         vnfd_helper.port_pairs.all_ports = []
2071         with self.assertRaises(AssertionError):
2072             with data_helper:
2073                 pass
2074
2075         vnfd_helper.port_pairs.all_ports = [0, 1, 2]
2076         with self.assertRaises(AssertionError):
2077             with data_helper:
2078                 pass
2079
2080     def test_measure_tot_stats(self):
2081         vnfd_helper = mock.MagicMock()
2082         vnfd_helper.port_pairs.all_ports = list(range(4))
2083
2084         start = (3, 4, 1, 2)
2085         end = (9, 7, 6, 8)
2086
2087         sut = prox_helpers.ProxSocketHelper(mock.MagicMock())
2088         sut.get_all_tot_stats = mock.MagicMock(side_effect=[start, end])
2089
2090         data_helper = prox_helpers.ProxDataHelper(
2091             vnfd_helper, sut, None, None, 5.4, None)
2092
2093         self.assertIsNone(data_helper.measured_stats)
2094
2095         expected = {
2096             'start_tot': start,
2097             'end_tot': end,
2098             'delta': prox_helpers.TotStatsTuple(6, 3, 5, 6),
2099         }
2100         with data_helper.measure_tot_stats():
2101             pass
2102
2103         self.assertEqual(data_helper.measured_stats, expected)
2104
2105     def test_capture_tsc_hz(self):
2106         vnfd_helper = mock.MagicMock()
2107         vnfd_helper.port_pairs.all_ports = list(range(4))
2108
2109         sut = mock.MagicMock()
2110         sut.hz.return_value = '54.6'
2111
2112         data_helper = prox_helpers.ProxDataHelper(
2113             vnfd_helper, sut, None, None, None, None)
2114
2115         self.assertIsNone(data_helper.tsc_hz)
2116
2117         expected = 54.6
2118         data_helper.capture_tsc_hz()
2119         self.assertEqual(data_helper.tsc_hz, expected)
2120
2121
2122 class TestProxProfileHelper(unittest.TestCase):
2123
2124     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.utils')
2125     def test_get_cls(self, mock_utils):
2126         mock_type1 = mock.MagicMock()
2127         mock_type1.__prox_profile_type__ = 'another_type'
2128         mock_type2 = mock.MagicMock()
2129         mock_type2.__prox_profile_type__ = 'my_type'
2130         mock_utils.itersubclasses.return_value = [mock_type1, mock_type2]
2131
2132         self.assertEqual(prox_helpers.ProxProfileHelper.get_cls('my_type'),
2133                          mock_type2)
2134
2135     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.utils')
2136     def test_get_cls_default(self, mock_utils):
2137         mock_utils.itersubclasses.return_value = []
2138         prox_helpers.ProxProfileHelper.get_cls('my_type')
2139
2140     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.SocketTopology')
2141     def test_cpu_topology(self, mock_socket_topology):
2142         mock_socket_topology.parse_cpuinfo.return_value = 432
2143
2144         resource_helper = mock.MagicMock()
2145         resource_helper.setup_helper.ssh_helper.execute.return_value = 0, 'output', ''
2146
2147         helper = prox_helpers.ProxProfileHelper(resource_helper)
2148         self.assertIsNone(helper._cpu_topology)
2149         result = helper.cpu_topology
2150         self.assertEqual(result, 432)
2151         self.assertIs(result, helper._cpu_topology)
2152         self.assertIs(result, helper.cpu_topology)
2153
2154     # TODO(elfoley): Split this test; there are two sets of inputs/outputs
2155     def test_test_cores(self):
2156         resource_helper = mock.MagicMock()
2157         resource_helper.setup_helper.prox_config_data = []
2158
2159         helper = prox_helpers.ProxProfileHelper(resource_helper)
2160         helper._cpu_topology = []
2161
2162         expected = []
2163         result = helper.test_cores
2164         self.assertEqual(result, expected)
2165
2166         resource_helper.setup_helper.prox_config_data = [
2167             ('section1', []),
2168             ('section2', [
2169                 ('a', 'b'),
2170                 ('c', 'd'),
2171             ]),
2172             ('core 1s3', []),
2173             ('core 2s5', [
2174                 ('index', 8),
2175                 ('mode', ''),
2176             ]),
2177             ('core 3s1', [
2178                 ('index', 5),
2179                 ('mode', 'gen'),
2180             ]),
2181             ('core 4s9h', [
2182                 ('index', 7),
2183                 ('mode', 'gen'),
2184             ]),
2185         ]
2186
2187         helper = prox_helpers.ProxProfileHelper(resource_helper)
2188         helper._cpu_topology = {
2189             1: {
2190                 3: {
2191                     'key1': (23, 32),
2192                     'key2': (12, 21),
2193                     'key3': (44, 33),
2194                 },
2195             },
2196             9: {
2197                 4: {
2198                     'key1': (44, 32),
2199                     'key2': (23, 21),
2200                     'key3': (12, 33),
2201                 },
2202             },
2203         }
2204
2205         self.assertIsNone(helper._test_cores)
2206         expected = [3, 4]
2207         result = helper.test_cores
2208         self.assertEqual(result, expected)
2209         self.assertIs(result, helper._test_cores)
2210         self.assertIs(result, helper.test_cores)
2211
2212     # TODO(elfoley): Split this test; there are two sets of inputs/outputs
2213     def test_latency_cores(self):
2214         resource_helper = mock.MagicMock()
2215         resource_helper.setup_helper.prox_config_data = []
2216
2217         helper = prox_helpers.ProxProfileHelper(resource_helper)
2218         helper._cpu_topology = []
2219
2220         expected = []
2221         result = helper.latency_cores
2222         self.assertEqual(result, expected)
2223
2224         resource_helper.setup_helper.prox_config_data = [
2225             ('section1', []),
2226             ('section2', [
2227                 ('a', 'b'),
2228                 ('c', 'd'),
2229             ]),
2230             ('core 1s3', []),
2231             ('core 2s5', [
2232                 ('index', 8),
2233                 ('mode', ''),
2234             ]),
2235             ('core 3s1', [
2236                 ('index', 5),
2237                 ('mode', 'lat'),
2238             ]),
2239             ('core 4s9h', [
2240                 ('index', 7),
2241                 ('mode', 'lat'),
2242             ]),
2243         ]
2244
2245         helper = prox_helpers.ProxProfileHelper(resource_helper)
2246         helper._cpu_topology = {
2247             1: {
2248                 3: {
2249                     'key1': (23, 32),
2250                     'key2': (12, 21),
2251                     'key3': (44, 33),
2252                 },
2253             },
2254             9: {
2255                 4: {
2256                     'key1': (44, 32),
2257                     'key2': (23, 21),
2258                     'key3': (12, 33),
2259                 },
2260             },
2261         }
2262
2263         self.assertIsNone(helper._latency_cores)
2264         expected = [3, 4]
2265         result = helper.latency_cores
2266         self.assertEqual(result, expected)
2267         self.assertIs(result, helper._latency_cores)
2268         self.assertIs(result, helper.latency_cores)
2269
2270     def test_all_rx_cores(self):
2271         helper = prox_helpers.ProxBngProfileHelper(mock.MagicMock())
2272         helper._latency_cores = expected = [3, 4, 6]
2273         helper._test_cores = [5, 2, 1]
2274
2275         result = helper.all_rx_cores
2276         self.assertEqual(result, expected)
2277
2278     def test_get_cores(self):
2279         resource_helper = mock.MagicMock()
2280         resource_helper.setup_helper.prox_config_data = [
2281             ('section1', []),
2282             ('section2', [
2283                 ('a', 'b'),
2284                 ('c', 'd'),
2285             ]),
2286             ('core 1', []),
2287             ('core 2', [
2288                 ('index', 8),
2289                 ('mode', ''),
2290             ]),
2291             ('core 3', [
2292                 ('index', 5),
2293                 ('mode', 'gen'),
2294             ]),
2295             ('core 4', [
2296                 ('index', 7),
2297                 ('mode', 'gen'),
2298             ]),
2299         ]
2300
2301         helper = prox_helpers.ProxProfileHelper(resource_helper)
2302         helper._cpu_topology = {
2303             0: {
2304                 1: {
2305                     5: (5, 1, 0)
2306                 },
2307                 2: {
2308                     6: (6, 2, 0)
2309                 },
2310                 3: {
2311                     7: (7, 3, 0)
2312                 },
2313                 4: {
2314                     8: (8, 3, 0)
2315                 },
2316             }
2317         }
2318
2319         expected = [3, 4]
2320         result = helper.get_cores(helper.PROX_CORE_GEN_MODE)
2321         self.assertEqual(result, expected)
2322
2323     def test_get_latency(self):
2324         resource_helper = mock.MagicMock()
2325         resource_helper.setup_helper.vnfd_helper.interfaces = []
2326
2327         helper = prox_helpers.ProxProfileHelper(resource_helper)
2328         helper._latency_cores = []
2329
2330         expected = []
2331         result = helper.get_latency()
2332         self.assertEqual(result, expected)
2333
2334         helper._latency_cores = [1, 2]
2335         helper.client = mock.MagicMock()
2336
2337         expected = helper.sut.lat_stats()
2338         result = helper.get_latency()
2339         self.assertIs(result, expected)
2340
2341     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
2342     def test_traffic_context(self, *args):
2343         setup_helper = mock.MagicMock()
2344         setup_helper.vnfd_helper.interfaces = []
2345
2346         helper = prox_helpers.ProxProfileHelper(setup_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         setup_helper.prox_config_data = [
2365             ('global', [
2366                 ('not_name', 'other data'),
2367                 ('name_not', 'more data'),
2368                 ('name', helper.__prox_profile_type__),
2369             ]),
2370             ('section1', []),
2371             ('section2', [
2372                 ('a', 'b'),
2373                 ('c', 'd'),
2374             ]),
2375             ('core 1', []),
2376             ('core 2', [
2377                 ('index', 8),
2378                 ('mode', ''),
2379             ]),
2380             ('core 3', [
2381                 ('index', 5),
2382                 ('mode', 'gen'),
2383                 ('name', 'tagged'),
2384             ]),
2385             ('core 4', [
2386                 ('index', 7),
2387                 ('mode', 'gen'),
2388                 ('name', 'udp'),
2389             ]),
2390         ]
2391
2392         client = mock.MagicMock()
2393         client.hz.return_value = 2
2394
2395         helper.client = client
2396         helper.get_latency = mock.MagicMock(return_value=[3.3, 3.6, 3.8])
2397
2398         helper._test_cores = [3, 4]
2399
2400         with helper.traffic_context(64, 1):
2401             pass
2402
2403     def test_run_test(self, *args):
2404         resource_helper = mock.MagicMock()
2405         resource_helper.step_delta = 0.4
2406         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2407         resource_helper.sut.multi_port_stats.return_value = (True, [[0, 1, 1, 2, 4, 5],
2408                                                                     [1, 1, 2, 3, 4, 5]])
2409
2410         helper = prox_helpers.ProxProfileHelper(resource_helper)
2411
2412         helper.run_test(pkt_size=120, duration=5, value=6.5, tolerated_loss=0.0,
2413                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2414         self.assertTrue(resource_helper.sut.multi_port_stats.called)
2415         self.assertTrue(resource_helper.sut.stop_all.called)
2416         self.assertTrue(resource_helper.sut.reset_stats.called)
2417
2418 class TestProxMplsProfileHelper(unittest.TestCase):
2419
2420     def test_mpls_cores(self):
2421         resource_helper = mock.MagicMock()
2422         resource_helper.setup_helper.prox_config_data = [
2423             ('section1', []),
2424             ('section2', [
2425                 ('a', 'b'),
2426                 ('c', 'd'),
2427             ]),
2428             ('core 1', []),
2429             ('core 2', [
2430                 ('index', 8),
2431                 ('mode', ''),
2432             ]),
2433             ('core 3', [
2434                 ('index', 5),
2435                 ('mode', 'gen'),
2436                 ('name', 'tagged'),
2437             ]),
2438             ('core 4', [
2439                 ('index', 7),
2440                 ('mode', 'gen'),
2441                 ('name', 'udp'),
2442             ]),
2443         ]
2444
2445         helper = prox_helpers.ProxMplsProfileHelper(resource_helper)
2446         helper._cpu_topology = {
2447             0: {
2448                 1: {
2449                     5: (5, 1, 0)
2450                 },
2451                 2: {
2452                     6: (6, 2, 0)
2453                 },
2454                 3: {
2455                     7: (7, 3, 0)
2456                 },
2457                 4: {
2458                     8: (8, 3, 0)
2459                 },
2460             }
2461         }
2462
2463         expected_tagged = [3]
2464         expected_plain = [4]
2465         self.assertIsNone(helper._cores_tuple)
2466         self.assertEqual(helper.tagged_cores, expected_tagged)
2467         self.assertEqual(helper.plain_cores, expected_plain)
2468         self.assertEqual(helper._cores_tuple, (expected_tagged, expected_plain))
2469
2470     def test_traffic_context(self):
2471         setup_helper = mock.MagicMock()
2472         helper = prox_helpers.ProxMplsProfileHelper(setup_helper)
2473
2474         with helper.traffic_context(120, 5.4):
2475             pass
2476
2477
2478 class TestProxBngProfileHelper(unittest.TestCase):
2479
2480     def test_bng_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             ('core 6', [
2504                 ('index', 3),
2505                 ('mode', 'gen'),
2506                 ('name', 'arp_task'),
2507             ]),
2508             ('core 9', [
2509                 ('index', 2),
2510                 ('mode', 'gen'),
2511                 ('name', 'arp'),
2512             ]),
2513         ]
2514
2515         helper = prox_helpers.ProxBngProfileHelper(resource_helper)
2516         helper._cpu_topology = {
2517             0: {
2518                 1: {
2519                     5: (5, 1, 0)
2520                 },
2521                 2: {
2522                     6: (6, 2, 0)
2523                 },
2524                 3: {
2525                     7: (7, 3, 0)
2526                 },
2527                 4: {
2528                     8: (8, 3, 0)
2529                 },
2530                 6: {
2531                     1: (4, 8, 0)
2532                 },
2533                 9: {
2534                     2: (3, 7, 0)
2535                 },
2536             }
2537         }
2538
2539         expected_cpe = [3]
2540         expected_inet = [4]
2541         expected_arp = [6, 9]
2542         expected_arp_task = [0, 6]
2543         expected_combined = (expected_cpe, expected_inet, expected_arp, expected_arp_task)
2544
2545         self.assertIsNone(helper._cores_tuple)
2546         self.assertEqual(helper.cpe_cores, expected_cpe)
2547         self.assertEqual(helper.inet_cores, expected_inet)
2548         self.assertEqual(helper.arp_cores, expected_arp)
2549         self.assertEqual(helper.arp_task_cores, expected_arp_task)
2550         self.assertEqual(helper._cores_tuple, expected_combined)
2551
2552     def test_run_test(self, *args):
2553         resource_helper = mock.MagicMock()
2554         resource_helper.step_delta = 0.4
2555         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2556         resource_helper.sut.multi_port_stats.return_value = (True, [[0, 1, 1, 2, 4, 5],
2557                                                                     [1, 1, 2, 3, 4, 5]])
2558
2559         helper = prox_helpers.ProxBngProfileHelper(resource_helper)
2560
2561         helper.run_test(pkt_size=120, duration=5, value=6.5, tolerated_loss=0.0,
2562                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2563         self.assertTrue(resource_helper.sut.multi_port_stats.called)
2564         self.assertTrue(resource_helper.sut.stop_all.called)
2565         self.assertTrue(resource_helper.sut.reset_stats.called)
2566
2567         resource_helper.reset_mock()
2568
2569         # negative pkt_size is the only way to make ratio > 1
2570         helper.run_test(pkt_size=-1000, duration=5, value=6.5, tolerated_loss=0.0,
2571                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2572
2573         self.assertTrue(resource_helper.sut.multi_port_stats.called)
2574         self.assertTrue(resource_helper.sut.stop_all.called)
2575         self.assertTrue(resource_helper.sut.reset_stats.called)
2576
2577 class TestProxVpeProfileHelper(unittest.TestCase):
2578
2579     def test_vpe_cores(self):
2580         resource_helper = mock.MagicMock()
2581         resource_helper.setup_helper.prox_config_data = [
2582             ('section1', []),
2583             ('section2', [
2584                 ('a', 'b'),
2585                 ('c', 'd'),
2586             ]),
2587             ('core 1', []),
2588             ('core 2', [
2589                 ('index', 8),
2590                 ('mode', ''),
2591             ]),
2592             ('core 3', [
2593                 ('index', 5),
2594                 ('mode', 'gen'),
2595                 ('name', 'cpe'),
2596             ]),
2597             ('core 4', [
2598                 ('index', 7),
2599                 ('mode', 'gen'),
2600                 ('name', 'inet'),
2601             ]),
2602         ]
2603
2604         helper = prox_helpers.ProxVpeProfileHelper(resource_helper)
2605         helper._cpu_topology = {
2606             0: {
2607                 1: {
2608                     5: (5, 1, 0)
2609                 },
2610                 2: {
2611                     6: (6, 2, 0)
2612                 },
2613                 3: {
2614                     7: (7, 3, 0)
2615                 },
2616                 4: {
2617                     8: (8, 3, 0)
2618                 },
2619             }
2620         }
2621
2622         expected_cpe = [3]
2623         expected_inet = [4]
2624         expected_combined = (expected_cpe, expected_inet)
2625
2626         self.assertIsNone(helper._cores_tuple)
2627         self.assertEqual(helper.cpe_cores, expected_cpe)
2628         self.assertEqual(helper.inet_cores, expected_inet)
2629         self.assertEqual(helper._cores_tuple, expected_combined)
2630
2631     def test_vpe_ports(self):
2632         resource_helper = mock.MagicMock()
2633         resource_helper.setup_helper.prox_config_data = [
2634             ('section1', []),
2635             ('section2', [
2636                 ('a', 'b'),
2637                 ('c', 'd'),
2638             ]),
2639             ('port 3', [
2640                 ('index', '5'),
2641                 ('name', 'cpe'),
2642                 ('mac', 'hardware'),
2643             ]),
2644             ('port 4', [
2645                 ('index', '7'),
2646                 ('name', 'inet'),
2647                 ('mac', 'hardware'),
2648             ]),
2649         ]
2650
2651         helper = prox_helpers.ProxVpeProfileHelper(resource_helper)
2652         helper._port_list = {
2653             0: {
2654                 1: {
2655                     5: 'cpe'
2656                 },
2657                 2: {
2658                     6: 'inet'
2659                 },
2660                 3: {
2661                     7: 'cpe'
2662                 },
2663                 4: {
2664                     8: 'inet'
2665                 },
2666             }
2667         }
2668
2669         expected_cpe = [3]
2670         expected_inet = [4]
2671         expected_combined = (expected_cpe, expected_inet)
2672
2673         self.assertIsNone(helper._ports_tuple)
2674         self.assertEqual(helper.cpe_ports, expected_cpe)
2675         self.assertEqual(helper.inet_ports, expected_inet)
2676         self.assertEqual(helper._ports_tuple, expected_combined)
2677
2678     def test_run_test(self, *args):
2679         resource_helper = mock.MagicMock()
2680         resource_helper.step_delta = 0.4
2681         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2682         resource_helper.sut.multi_port_stats.return_value = (True, [[0, 1, 1, 2, 4, 5],
2683                                                                     [1, 1, 2, 3, 4, 5]])
2684
2685         helper = prox_helpers.ProxVpeProfileHelper(resource_helper)
2686
2687         helper.run_test(pkt_size=120, duration=5, value=6.5, tolerated_loss=0.0,
2688                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2689
2690         # negative pkt_size is the only way to make ratio > 1
2691         helper.run_test(pkt_size=-1000, duration=5, value=6.5, tolerated_loss=0.0,
2692                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2693
2694 class TestProxlwAFTRProfileHelper(unittest.TestCase):
2695
2696     def test_lwaftr_cores(self):
2697         resource_helper = mock.MagicMock()
2698         resource_helper.setup_helper.prox_config_data = [
2699             ('section1', []),
2700             ('section2', [
2701                 ('a', 'b'),
2702                 ('c', 'd'),
2703             ]),
2704             ('core 1', []),
2705             ('core 2', [
2706                 ('index', 8),
2707                 ('mode', ''),
2708             ]),
2709             ('core 3', [
2710                 ('index', 5),
2711                 ('mode', 'gen'),
2712                 ('name', 'tun'),
2713             ]),
2714             ('core 4', [
2715                 ('index', 7),
2716                 ('mode', 'gen'),
2717                 ('name', 'inet'),
2718             ]),
2719         ]
2720
2721         helper = prox_helpers.ProxlwAFTRProfileHelper(resource_helper)
2722         helper._cpu_topology = {
2723             0: {
2724                 1: {
2725                     5: (5, 1, 0)
2726                 },
2727                 2: {
2728                     6: (6, 2, 0)
2729                 },
2730                 3: {
2731                     7: (7, 3, 0)
2732                 },
2733                 4: {
2734                     8: (8, 3, 0)
2735                 },
2736             }
2737         }
2738
2739         expected_tun = [3]
2740         expected_inet = [4]
2741         expected_combined = (expected_tun, expected_inet)
2742
2743         self.assertIsNone(helper._cores_tuple)
2744         self.assertEqual(helper.tun_cores, expected_tun)
2745         self.assertEqual(helper.inet_cores, expected_inet)
2746         self.assertEqual(helper._cores_tuple, expected_combined)
2747
2748     def test_tun_ports(self):
2749         resource_helper = mock.MagicMock()
2750         resource_helper.setup_helper.prox_config_data = [
2751             ('section1', []),
2752             ('section2', [
2753                 ('a', 'b'),
2754                 ('c', 'd'),
2755             ]),
2756             ('port 3', [
2757                 ('index', '5'),
2758                 ('name', 'lwB4'),
2759                 ('mac', 'hardware'),
2760             ]),
2761             ('port 4', [
2762                 ('index', '7'),
2763                 ('name', 'inet'),
2764                 ('mac', 'hardware'),
2765             ]),
2766         ]
2767
2768         helper = prox_helpers.ProxlwAFTRProfileHelper(resource_helper)
2769         helper._port_list = {
2770             0: {
2771                 1: {
2772                     5: 'lwB4'
2773                 },
2774                 2: {
2775                     6: 'inet'
2776                 },
2777                 3: {
2778                     7: 'lwB4'
2779                 },
2780                 4: {
2781                     8: 'inet'
2782                 },
2783             }
2784         }
2785
2786         expected_tun = [3]
2787         expected_inet = [4]
2788         expected_combined = (expected_tun, expected_inet)
2789
2790         self.assertIsNone(helper._ports_tuple)
2791         self.assertEqual(helper.tun_ports, expected_tun)
2792         self.assertEqual(helper.inet_ports, expected_inet)
2793         self.assertEqual(helper._ports_tuple, expected_combined)
2794
2795     def test_run_test(self, *args):
2796         resource_helper = mock.MagicMock()
2797         resource_helper.step_delta = 0.4
2798         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2799         resource_helper.sut.multi_port_stats.return_value = (True, [[0, 1, 2, 4, 6, 5],
2800                                                                     [1, 1, 2, 3, 4, 5]])
2801
2802         helper = prox_helpers.ProxlwAFTRProfileHelper(resource_helper)
2803
2804         helper.run_test(pkt_size=120, duration=5, value=6.5, tolerated_loss=0.0,
2805                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2806
2807         # negative pkt_size is the only way to make ratio > 1
2808         helper.run_test(pkt_size=-1000, duration=5, value=6.5, tolerated_loss=0.0,
2809                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2810
2811
2812 class TestProxIrqProfileHelper(unittest.TestCase):
2813
2814     def test_run_test(self, *args):
2815         resource_helper = mock.MagicMock()
2816         helper = prox_helpers.ProxIrqProfileHelper(resource_helper)
2817         self.assertIsNone(helper._cores_tuple)
2818         self.assertIsNone(helper._ports_tuple)
2819         self.assertIsNone(helper._latency_cores)
2820         self.assertIsNone(helper._test_cores)
2821         self.assertIsNone(helper._cpu_topology)