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

   1 #!/usr/bin/env python
   2
   3 # Copyright (c) 2016-2017 Intel Corporation
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #      http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16 #
  17
  18 from __future__ import absolute_import
  19
  20 import copy
  21 import os
  22 import socket
  23 import unittest
  24 from itertools import repeat, chain
  25 from contextlib import contextmanager
  26 import mock
  27
  28 from tests.unit import STL_MOCKS
  29 from yardstick.network_services.vnf_generic.vnf.base import VnfdHelper
  30
  31 STLClient = mock.MagicMock()
  32 stl_patch = mock.patch.dict("sys.modules", STL_MOCKS)
  33 stl_patch.start()
  34
  35 if stl_patch:
  36     from yardstick.network_services.vnf_generic.vnf.sample_vnf import ScenarioHelper
  37     from yardstick.network_services.vnf_generic.vnf.prox_helpers import ProxSocketHelper
  38     from yardstick.network_services.vnf_generic.vnf.prox_helpers import PacketDump
  39     from yardstick.network_services.vnf_generic.vnf.prox_helpers import CoreSocketTuple
  40     from yardstick.network_services.vnf_generic.vnf.prox_helpers import ProxTestDataTuple
  41     from yardstick.network_services.vnf_generic.vnf.prox_helpers import ProxDpdkVnfSetupEnvHelper
  42     from yardstick.network_services.vnf_generic.vnf.prox_helpers import TotStatsTuple
  43     from yardstick.network_services.vnf_generic.vnf.prox_helpers import ProxDataHelper
  44     from yardstick.network_services.vnf_generic.vnf.prox_helpers import ProxResourceHelper
  45     from yardstick.network_services.vnf_generic.vnf.prox_helpers import ProxProfileHelper
  46     from yardstick.network_services.vnf_generic.vnf.prox_helpers import ProxMplsProfileHelper
  47     from yardstick.network_services.vnf_generic.vnf.prox_helpers import ProxBngProfileHelper
  48
  49
  50 class TestCoreTuple(unittest.TestCase):
  51     def test___init__(self):
  52         core_tuple = CoreSocketTuple('core 5s6')
  53         self.assertEqual(core_tuple.core_id, 5)
  54         self.assertEqual(core_tuple.socket_id, 6)
  55         self.assertFalse(core_tuple.is_hyperthread())
  56
  57         core_tuple = CoreSocketTuple('core 5s6h')
  58         self.assertEqual(core_tuple.core_id, 5)
  59         self.assertEqual(core_tuple.socket_id, 6)
  60         self.assertTrue(core_tuple.is_hyperthread())
  61
  62     def test___init__negative(self):
  63         bad_inputs = [
  64             '',
  65             '5',
  66             '5s',
  67             '6h',
  68             '5s6',
  69             'core',
  70             'core h',
  71             'core 5s',
  72             'core 5 6',
  73             'core 5 6h',
  74             'core 5d6',
  75             'core 5d6h',
  76             1,
  77             2.3,
  78             [],
  79             {},
  80             object(),
  81         ]
  82
  83         for bad_input in bad_inputs:
  84             with self.assertRaises(ValueError):
  85                 CoreSocketTuple(bad_input)
  86
  87     def test_find_in_topology(self):
  88         topology_in = {
  89             6: {
  90                 5: {
  91                     'key1': ['a', 'b'],
  92                     'key2': ['c', 'd'],
  93                 },
  94             },
  95         }
  96
  97         core_tuple = CoreSocketTuple('core 5s6')
  98
  99         expected = 'a'
 100         result = core_tuple.find_in_topology(topology_in)
 101         self.assertEqual(result, expected)
 102
 103         core_tuple = CoreSocketTuple('core 5s6h')
 104
 105         expected = 'c'
 106         result = core_tuple.find_in_topology(topology_in)
 107         self.assertEqual(result, expected)
 108
 109     def test_find_in_topology_negative(self):
 110         core_tuple = CoreSocketTuple('core 6s5')
 111         with self.assertRaises(ValueError):
 112             # no socket key
 113             core_tuple.find_in_topology({})
 114
 115         with self.assertRaises(ValueError):
 116             # no core key
 117             core_tuple.find_in_topology({5: {}})
 118
 119         with self.assertRaises(ValueError):
 120             # no first value (as needed by non-hyperthread core)
 121             core_tuple.find_in_topology({5: {6: {'key1': []}}})
 122
 123         core_tuple = CoreSocketTuple('core 6s5h')
 124         with self.assertRaises(ValueError):
 125             # no second value (as needed by hyperthread core)
 126             core_tuple.find_in_topology({5: {6: {'key1': ['e']}}})
 127
 128
 129 class TestTotStatsTuple(unittest.TestCase):
 130     def test___new___negative(self):
 131         with self.assertRaises(TypeError):
 132             # no values
 133             TotStatsTuple()
 134
 135         with self.assertRaises(TypeError):
 136             # one, non-integer value
 137             TotStatsTuple('a')
 138
 139         with self.assertRaises(TypeError):
 140             # too many values
 141             TotStatsTuple(3, 4, 5, 6, 7)
 142
 143
 144 class TestProxTestDataTuple(unittest.TestCase):
 145     def test___init__(self):
 146         prox_test_data = ProxTestDataTuple(1, 2, 3, 4, 5, 6, 7, 8, 9)
 147         self.assertEqual(prox_test_data.tolerated, 1)
 148         self.assertEqual(prox_test_data.tsc_hz, 2)
 149         self.assertEqual(prox_test_data.delta_rx, 3)
 150         self.assertEqual(prox_test_data.delta_tx, 4)
 151         self.assertEqual(prox_test_data.delta_tsc, 5)
 152         self.assertEqual(prox_test_data.latency, 6)
 153         self.assertEqual(prox_test_data.rx_total, 7)
 154         self.assertEqual(prox_test_data.tx_total, 8)
 155         self.assertEqual(prox_test_data.pps, 9)
 156
 157     def test_properties(self):
 158         prox_test_data = ProxTestDataTuple(1, 2, 3, 4, 5, 6, 7, 8, 9)
 159         self.assertEqual(prox_test_data.pkt_loss, 12.5)
 160         self.assertEqual(prox_test_data.mpps, 1.6 / 1e6)
 161         self.assertEqual(prox_test_data.can_be_lost, 0)
 162         self.assertEqual(prox_test_data.drop_total, 1)
 163         self.assertFalse(prox_test_data.success)
 164
 165         prox_test_data = ProxTestDataTuple(10, 2, 3, 4, 5, 6, 997, 998, 9)
 166         self.assertTrue(prox_test_data.success)
 167
 168     def test_pkt_loss_zero_division(self):
 169         prox_test_data = ProxTestDataTuple(1, 2, 3, 4, 5, 6, 7, 0, 9)
 170         self.assertEqual(prox_test_data.pkt_loss, 100.0)
 171
 172     def test_get_samples(self):
 173         prox_test_data = ProxTestDataTuple(1, 2, 3, 4, 5, [6.1, 6.9, 6.4], 7, 8, 9)
 174
 175         expected = {
 176             "Throughput": 1.6 / 1e6,
 177             "DropPackets": 12.5,
 178             "CurrentDropPackets": 12.5,
 179             "TxThroughput": 9 / 1e6,
 180             "RxThroughput": 1.6 / 1e6,
 181             "PktSize": 64,
 182             "PortSample": 1,
 183             "LatencyMin": 6.1,
 184             "LatencyMax": 6.9,
 185             "LatencyAvg": 6.4,
 186         }
 187         result = prox_test_data.get_samples(64, port_samples={"PortSample": 1})
 188         self.assertDictEqual(result, expected)
 189
 190         expected = {
 191             "Throughput": 1.6 / 1e6,
 192             "DropPackets": 0.123,
 193             "CurrentDropPackets": 0.123,
 194             "TxThroughput": 9 / 1e6,
 195             "RxThroughput": 1.6 / 1e6,
 196             "PktSize": 64,
 197             "LatencyMin": 6.1,
 198             "LatencyMax": 6.9,
 199             "LatencyAvg": 6.4,
 200         }
 201         result = prox_test_data.get_samples(64, 0.123)
 202         self.assertDictEqual(result, expected)
 203
 204     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.LOG')
 205     def test_log_data(self, mock_logger):
 206         my_mock_logger = mock.MagicMock()
 207         prox_test_data = ProxTestDataTuple(1, 2, 3, 4, 5, [6.1, 6.9, 6.4], 7, 8, 9)
 208         prox_test_data.log_data()
 209         self.assertEqual(my_mock_logger.debug.call_count, 0)
 210         self.assertEqual(mock_logger.debug.call_count, 2)
 211
 212         mock_logger.debug.reset_mock()
 213         prox_test_data.log_data(my_mock_logger)
 214         self.assertEqual(my_mock_logger.debug.call_count, 2)
 215         self.assertEqual(mock_logger.debug.call_count, 0)
 216
 217
 218 class TestPacketDump(unittest.TestCase):
 219     PAYLOAD = "payload"
 220
 221     def test__init__(self):
 222         PacketDump("port_id", len(self.PAYLOAD), self.PAYLOAD)
 223
 224     def test___str__(self):
 225         expected = '<PacketDump port: port_id payload: {}>'.format(self.PAYLOAD)
 226         dump1 = PacketDump("port_id", len(self.PAYLOAD), self.PAYLOAD)
 227         self.assertEqual(str(dump1), expected)
 228
 229     def test_port_id(self):
 230         p = PacketDump("port_id", len(self.PAYLOAD), self.PAYLOAD)
 231         self.assertEqual(p.port_id, "port_id")
 232
 233     def test_data_len(self):
 234         p = PacketDump("port_id", len(self.PAYLOAD), self.PAYLOAD)
 235         self.assertEqual(p.data_len, len(self.PAYLOAD))
 236
 237     def test_payload(self):
 238         p = PacketDump("port_id", len(self.PAYLOAD), self.PAYLOAD)
 239         self.assertEqual(p.payload(), self.PAYLOAD)
 240
 241         self.assertEqual(p.payload(3), self.PAYLOAD[3:])
 242
 243         self.assertEqual(p.payload(end=3), self.PAYLOAD[:4])
 244
 245         self.assertEqual(p.payload(2, 4), self.PAYLOAD[2:5])
 246
 247
 248 PACKET_DUMP_1 = """\
 249 pktdump,3,11
 250 hello world
 251 """
 252
 253 PACKET_DUMP_2 = """\
 254 pktdump,3,11
 255 hello world
 256 pktdump,2,9
 257 brown fox jumped over
 258 pktdump,4,8
 259 lazy
 260 dog
 261 """
 262
 263 PACKET_DUMP_NON_1 = """\
 264 not_a_dump,1,2
 265 other data
 266 """
 267
 268 PACKET_DUMP_MIXED_1 = """\
 269 pktdump,3,11
 270 hello world
 271 not_a_dump,1,2
 272 other data
 273 """
 274
 275 PACKET_DUMP_BAD_1 = """\
 276 pktdump,one,12
 277 bad port id
 278 """
 279
 280 PACKET_DUMP_BAD_2 = """\
 281 pktdump,3,twelve
 282 bad data length
 283 """
 284
 285 PACKET_DUMP_BAD_3 = """\
 286 pktdump,3
 287 no data length value
 288 """
 289
 290
 291 @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
 292 class TestProxSocketHelper(unittest.TestCase):
 293     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.socket')
 294     def test___init__(self, mock_socket, mock_time):
 295         expected = mock_socket.socket()
 296         prox = ProxSocketHelper()
 297         result = prox._sock
 298         self.assertEqual(result, expected)
 299
 300     def test_connect(self, mock_time):
 301         mock_sock = mock.MagicMock()
 302         prox = ProxSocketHelper(mock_sock)
 303         prox.connect('10.20.30.40', 23456)
 304         self.assertEqual(mock_sock.connect.call_count, 1)
 305
 306     def test_get_sock(self, mock_time):
 307         mock_sock = mock.MagicMock()
 308         prox = ProxSocketHelper(mock_sock)
 309         result = prox.get_socket()
 310         self.assertIs(result, mock_sock)
 311
 312     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.select')
 313     def test_get_data(self, mock_select, mock_time):
 314         mock_select.select.side_effect = [[1], [0]]
 315         mock_socket = mock.MagicMock()
 316         mock_recv = mock_socket.recv()
 317         mock_recv.decode.return_value = ""
 318         prox = ProxSocketHelper(mock_socket)
 319         ret = prox.get_data()
 320         self.assertEqual(ret, "")
 321         self.assertEqual(len(prox._pkt_dumps), 0)
 322
 323         mock_select.select.reset_mock()
 324         mock_select.select.side_effect = chain([['a'], ['']], 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]], repeat([1], 3))
 333         mock_recv.decode.return_value = PACKET_DUMP_2
 334         ret = prox.get_data()
 335         self.assertEqual(mock_select.select.call_count, 2)
 336         self.assertEqual(ret, 'jumped over')
 337         self.assertEqual(len(prox._pkt_dumps), 3)
 338
 339     def test__parse_socket_data_mixed_data(self, mock_time):
 340         prox = ProxSocketHelper(mock.MagicMock())
 341         ret = prox._parse_socket_data(PACKET_DUMP_NON_1, False)
 342         self.assertEqual(ret, 'not_a_dump,1,2')
 343         self.assertEqual(len(prox._pkt_dumps), 0)
 344
 345         ret = prox._parse_socket_data(PACKET_DUMP_MIXED_1, False)
 346         self.assertEqual(ret, 'not_a_dump,1,2')
 347         self.assertEqual(len(prox._pkt_dumps), 1)
 348
 349     def test__parse_socket_data_bad_data(self, mock_time):
 350         prox = ProxSocketHelper(mock.MagicMock())
 351         with self.assertRaises(ValueError):
 352             prox._parse_socket_data(PACKET_DUMP_BAD_1, False)
 353
 354         with self.assertRaises(ValueError):
 355             prox._parse_socket_data(PACKET_DUMP_BAD_2, False)
 356
 357         ret = prox._parse_socket_data(PACKET_DUMP_BAD_3, False)
 358         self.assertEqual(ret, 'pktdump,3')
 359
 360     def test__parse_socket_data_pkt_dump_only(self, mock_time):
 361         prox = ProxSocketHelper(mock.MagicMock())
 362         ret = prox._parse_socket_data('', True)
 363         self.assertFalse(ret)
 364
 365         ret = prox._parse_socket_data(PACKET_DUMP_1, True)
 366         self.assertTrue(ret)
 367
 368         ret = prox._parse_socket_data(PACKET_DUMP_2, True)
 369         self.assertTrue(ret)
 370
 371     def test_put_command(self, mock_time):
 372         mock_socket = mock.MagicMock()
 373         prox = ProxSocketHelper(mock_socket)
 374         prox.put_command("data")
 375         mock_socket.sendall.assert_called_once()
 376
 377     def test_put_command_socket_error(self, mock_time):
 378         mock_socket = mock.MagicMock()
 379         mock_socket.sendall.side_effect = OSError
 380         prox = ProxSocketHelper(mock_socket)
 381         prox.put_command("data")
 382         mock_socket.sendall.assert_called_once()
 383
 384     def test_get_packet_dump(self, mock_time):
 385         mock_socket = mock.MagicMock()
 386         prox = ProxSocketHelper(mock_socket)
 387         prox._pkt_dumps = []
 388         self.assertIsNone(prox.get_packet_dump())
 389
 390         prox._pkt_dumps = [234]
 391         self.assertEqual(prox.get_packet_dump(), 234)
 392         self.assertEqual(prox._pkt_dumps, [])
 393
 394     def test_stop_all_reset(self, mock_time):
 395         mock_socket = mock.MagicMock()
 396         prox = ProxSocketHelper(mock_socket)
 397         prox.stop_all_reset()
 398         mock_socket.sendall.assert_called()
 399
 400     def test_stop_all(self, mock_time):
 401         mock_socket = mock.MagicMock()
 402         prox = ProxSocketHelper(mock_socket)
 403         prox.stop_all()
 404         mock_socket.sendall.assert_called()
 405
 406     def test_stop(self, mock_time):
 407         mock_socket = mock.MagicMock()
 408         prox = ProxSocketHelper(mock_socket)
 409         prox.stop([3, 4, 5], 16)
 410         mock_socket.sendall.assert_called()
 411
 412     def test_start_all(self, mock_time):
 413         mock_socket = mock.MagicMock()
 414         prox = ProxSocketHelper(mock_socket)
 415         prox.start_all()
 416         mock_socket.sendall.assert_called()
 417
 418     def test_start(self, mock_time):
 419         mock_socket = mock.MagicMock()
 420         prox = ProxSocketHelper(mock_socket)
 421         prox.start([3, 4, 5])
 422         mock_socket.sendall.assert_called()
 423
 424     def test_reset_stats(self, mock_time):
 425         mock_socket = mock.MagicMock()
 426         prox = ProxSocketHelper(mock_socket)
 427         prox.reset_stats()
 428         mock_socket.sendall.assert_called()
 429
 430     def test_set_pkt_size(self, mock_time):
 431         mock_socket = mock.MagicMock()
 432         prox = ProxSocketHelper(mock_socket)
 433         prox.set_pkt_size([3, 4, 5], 1024)
 434         self.assertEqual(mock_socket.sendall.call_count, 3)
 435
 436     def test_set_value(self, mock_time):
 437         mock_socket = mock.MagicMock()
 438         prox = ProxSocketHelper(mock_socket)
 439         prox.set_value([3, 4, 5], 10, 20, 30)
 440         self.assertEqual(mock_socket.sendall.call_count, 3)
 441
 442     def test_reset_values(self, mock_time):
 443         mock_socket = mock.MagicMock()
 444         prox = ProxSocketHelper(mock_socket)
 445         prox.reset_values([3, 4, 5])
 446         self.assertEqual(mock_socket.sendall.call_count, 3)
 447
 448     def test_set_speed(self, mock_time):
 449         mock_socket = mock.MagicMock()
 450         prox = ProxSocketHelper(mock_socket)
 451         prox.set_speed([3, 4, 5], 1000)
 452         self.assertEqual(mock_socket.sendall.call_count, 3)
 453
 454     def test_slope_speed(self, mock_time):
 455         core_data = [
 456             {
 457                 'cores': [3, 4, 5],
 458                 'speed': 1000,
 459             },
 460             {
 461                 'cores': [9, 10, 11],
 462                 'speed': '500.5',
 463             },
 464         ]
 465
 466         mock_socket = mock.MagicMock()
 467         prox = ProxSocketHelper(mock_socket)
 468         prox.set_speed = set_speed = mock.MagicMock()
 469         prox.slope_speed(core_data, 5)
 470         self.assertEqual(set_speed.call_count, 20)
 471
 472         set_speed.reset_mock()
 473         prox.slope_speed(core_data, 5, 5)
 474         self.assertEqual(set_speed.call_count, 10)
 475
 476     def test_set_pps(self, mock_time):
 477         mock_socket = mock.MagicMock()
 478         prox = ProxSocketHelper(mock_socket)
 479         prox.set_pps([3, 4, 5], 1000, 512)
 480         self.assertEqual(mock_socket.sendall.call_count, 3)
 481
 482     def test_lat_stats(self, mock_time):
 483         latency_output = [
 484             '1, 2 , 3',  # has white space
 485             '4,5',  # too short
 486             '7,8,9,10.5,11',  # too long with float, but float is in unused portion
 487             'twelve,13,14',  # value as English word
 488             '15,16.2,17',  # float in used portion
 489         ]
 490
 491         mock_socket = mock.MagicMock()
 492         prox = ProxSocketHelper(mock_socket)
 493         prox.get_data = mock.MagicMock(side_effect=latency_output)
 494
 495         expected = (
 496             {
 497                 3: 1,
 498                 5: 7,
 499             },
 500             {
 501                 3: 2,
 502                 5: 8,
 503             },
 504             {
 505                 3: 3,
 506                 5: 9,
 507             },
 508         )
 509         result = prox.lat_stats([3, 4, 5, 6, 7], 16)
 510         self.assertEqual(mock_socket.sendall.call_count, 5)
 511         self.assertEqual(result, expected)
 512
 513     def test_get_all_tot_stats_error(self, mock_time):
 514         mock_socket = mock.MagicMock()
 515         prox = ProxSocketHelper(mock_socket)
 516         prox.get_data = mock.MagicMock(return_value='3,4,5')
 517         expected = [0, 0, 0, 0]
 518         result = prox.get_all_tot_stats()
 519         self.assertEqual(result, expected)
 520
 521     def test_get_all_tot_stats(self, mock_time):
 522         mock_socket = mock.MagicMock()
 523         prox = ProxSocketHelper(mock_socket)
 524         prox.get_data = mock.MagicMock(return_value='3,4,5,6')
 525         expected = 3, 4, 5, 6
 526         result = prox.get_all_tot_stats()
 527         self.assertEqual(result, expected)
 528
 529     def test_hz(self, mock_time):
 530         mock_socket = mock.MagicMock()
 531         prox = ProxSocketHelper(mock_socket)
 532         prox.get_data = mock.MagicMock(return_value='3,4,5,6')
 533         expected = 6
 534         result = prox.hz()
 535         self.assertEqual(result, expected)
 536
 537     def test_rx_stats(self, mock_time):
 538         core_stats = [
 539             '3,4,5,6',
 540             '7,8,9,10,NaN',
 541             '11,12,13,14,15',
 542         ]
 543
 544         mock_socket = mock.MagicMock()
 545         prox = ProxSocketHelper(mock_socket)
 546         prox.get_data = mock.MagicMock(side_effect=core_stats)
 547         expected = 21, 24, 27, 14
 548         result = prox.rx_stats([3, 4, 5], 16)
 549         self.assertEqual(result, expected)
 550
 551     def test_core_stats(self, mock_time):
 552         core_stats = [
 553             '3,4,5,6',
 554             '7,8,9,10,NaN',
 555             '11,12,13,14,15',
 556         ]
 557
 558         mock_socket = mock.MagicMock()
 559         prox = ProxSocketHelper(mock_socket)
 560         prox.get_data = mock.MagicMock(side_effect=core_stats)
 561         expected = 21, 24, 27, 14
 562         result = prox.core_stats([3, 4, 5], 16)
 563         self.assertEqual(result, expected)
 564
 565     def test_port_stats(self, mock_time):
 566         port_stats = [
 567             ','.join(str(n) for n in range(3, 15)),
 568             ','.join(str(n) for n in range(8, 32, 2)),
 569             ','.join(str(n) for n in range(5, 89, 7)),
 570         ]
 571
 572         mock_socket = mock.MagicMock()
 573         prox = ProxSocketHelper(mock_socket)
 574         prox.get_data = mock.MagicMock(side_effect=port_stats)
 575         expected = [16, 26, 36, 46, 56, 66, 76, 86, 96, 106, 116, 126]
 576         result = prox.port_stats([3, 4, 5])
 577         self.assertEqual(result, expected)
 578
 579     def test_measure_tot_stats(self, mock_time):
 580         start_tot = 3, 4, 5, 6
 581         end_tot = 7, 9, 11, 13
 582         delta_tot = 4, 5, 6, 7
 583
 584         get_data_output = [
 585             ','.join(str(n) for n in start_tot),
 586             ','.join(str(n) for n in end_tot),
 587         ]
 588
 589         mock_socket = mock.MagicMock()
 590         prox = ProxSocketHelper(mock_socket)
 591         prox.get_data = mock.MagicMock(side_effect=get_data_output)
 592         expected = {
 593             'start_tot': start_tot,
 594             'end_tot': end_tot,
 595             'delta': delta_tot,
 596         }
 597         with prox.measure_tot_stats() as result:
 598             pass
 599         self.assertEqual(result, expected)
 600
 601     def test_tot_stats(self, mock_time):
 602         mock_socket = mock.MagicMock()
 603         prox = ProxSocketHelper(mock_socket)
 604         prox.get_data = mock.MagicMock(return_value='3,4,5,6')
 605         expected = 3, 4, 5
 606         result = prox.tot_stats()
 607         self.assertEqual(result, expected)
 608
 609     def test_tot_ierrors(self, mock_time):
 610         mock_socket = mock.MagicMock()
 611         prox = ProxSocketHelper(mock_socket)
 612         prox.get_data = mock.MagicMock(return_value='3,4,5,6')
 613         expected = 3, 3
 614         result = prox.tot_ierrors()
 615         self.assertEqual(result, expected)
 616
 617     def test_set_count(self, mock_time):
 618         mock_socket = mock.MagicMock()
 619         prox = ProxSocketHelper(mock_socket)
 620         prox.set_count(432, [3, 4, 5])
 621         self.assertEqual(mock_socket.sendall.call_count, 3)
 622
 623     def test_dump_rx(self, mock_time):
 624         mock_socket = mock.MagicMock()
 625         prox = ProxSocketHelper(mock_socket)
 626         prox.dump_rx(3, 5, 8)
 627         self.assertEqual(mock_socket.sendall.call_count, 1)
 628
 629     def test_quit(self, mock_time):
 630         mock_socket = mock.MagicMock()
 631         prox = ProxSocketHelper(mock_socket)
 632         prox.quit()
 633         mock_socket.sendall.assert_called()
 634
 635     def test_force_quit(self, mock_time):
 636         mock_socket = mock.MagicMock()
 637         prox = ProxSocketHelper(mock_socket)
 638         prox.force_quit()
 639         mock_socket.sendall.assert_called()
 640
 641
 642 class TestProxDpdkVnfSetupEnvHelper(unittest.TestCase):
 643
 644     VNFD0 = {
 645         'short-name': 'ProxVnf',
 646         'vdu': [
 647             {
 648                 'routing_table': [
 649                     {
 650                         'network': '152.16.100.20',
 651                         'netmask': '255.255.255.0',
 652                         'gateway': '152.16.100.20',
 653                         'if': 'xe0',
 654                     },
 655                     {
 656                         'network': '152.16.40.20',
 657                         'netmask': '255.255.255.0',
 658                         'gateway': '152.16.40.20',
 659                         'if': 'xe1',
 660                     },
 661                 ],
 662                 'description': 'PROX approximation using DPDK',
 663                 'name': 'proxvnf-baremetal',
 664                 'nd_route_tbl': [
 665                     {
 666                         'network': '0064:ff9b:0:0:0:0:9810:6414',
 667                         'netmask': '112',
 668                         'gateway': '0064:ff9b:0:0:0:0:9810:6414',
 669                         'if': 'xe0',
 670                     },
 671                     {
 672                         'network': '0064:ff9b:0:0:0:0:9810:2814',
 673                         'netmask': '112',
 674                         'gateway': '0064:ff9b:0:0:0:0:9810:2814',
 675                         'if': 'xe1',
 676                     },
 677                 ],
 678                 'id': 'proxvnf-baremetal',
 679                 'external-interface': [
 680                     {
 681                         'virtual-interface': {
 682                             'dst_mac': '00:00:00:00:00:04',
 683                             'vpci': '0000:05:00.0',
 684                             'local_ip': '152.16.100.19',
 685                             'type': 'PCI-PASSTHROUGH',
 686                             'vld_id': 'uplink_0',
 687                             'netmask': '255.255.255.0',
 688                             'dpdk_port_num': 0,
 689                             'bandwidth': '10 Gbps',
 690                             'driver': "i40e",
 691                             'dst_ip': '152.16.100.19',
 692                             'local_iface_name': 'xe0',
 693                             'local_mac': '00:00:00:00:00:02',
 694                             'ifname': 'xe0',
 695                         },
 696                         'vnfd-connection-point-ref': 'xe0',
 697                         'name': 'xe0',
 698                     },
 699                     {
 700                         'virtual-interface': {
 701                             'dst_mac': '00:00:00:00:00:03',
 702                             'vpci': '0000:05:00.1',
 703                             'local_ip': '152.16.40.19',
 704                             'type': 'PCI-PASSTHROUGH',
 705                             'vld_id': 'downlink_0',
 706                             'driver': "i40e",
 707                             'netmask': '255.255.255.0',
 708                             'dpdk_port_num': 1,
 709                             'bandwidth': '10 Gbps',
 710                             'dst_ip': '152.16.40.20',
 711                             'local_iface_name': 'xe1',
 712                             'local_mac': '00:00:00:00:00:01',
 713                             'ifname': 'xe1',
 714                         },
 715                         'vnfd-connection-point-ref': 'xe1',
 716                         'name': 'xe1',
 717                     },
 718                 ],
 719             },
 720         ],
 721         'description': 'PROX approximation using DPDK',
 722         'mgmt-interface': {
 723             'vdu-id': 'proxvnf-baremetal',
 724             'host': '1.2.1.1',
 725             'password': 'r00t',
 726             'user': 'root',
 727             'ip': '1.2.1.1',
 728         },
 729         'benchmark': {
 730             'kpi': [
 731                 'packets_in',
 732                 'packets_fwd',
 733                 'packets_dropped',
 734             ],
 735         },
 736         'id': 'ProxApproxVnf',
 737         'name': 'ProxVnf',
 738     }
 739
 740     VNFD = {
 741         'vnfd:vnfd-catalog': {
 742             'vnfd': [
 743                 VNFD0,
 744             ],
 745         },
 746     }
 747
 748     def test_global_section(self):
 749         setup_helper = ProxDpdkVnfSetupEnvHelper(mock.MagicMock(), mock.MagicMock(),
 750                                                  mock.MagicMock())
 751
 752         setup_helper._prox_config_data = [('a', [])]
 753
 754         with self.assertRaises(KeyError):
 755             _ = setup_helper.global_section
 756
 757         global_section = (
 758             'global', [
 759                 ('not_name', 'other data'),
 760                 ('name_not', 'more data'),
 761                 ('name', 'prox type'),
 762             ],
 763         )
 764
 765         setup_helper._prox_config_data = [
 766             ('section1', []),
 767             ('section2', [
 768                 ('a', 'b'),
 769                 ('c', 'd'),
 770             ]),
 771             ('core 1', []),
 772             ('core 2', [
 773                 ('index', 8),
 774                 ('mode', ''),
 775             ]),
 776             global_section,
 777             ('core 3', [
 778                 ('index', 5),
 779                 ('mode', 'gen'),
 780                 ('name', 'tagged'),
 781             ]),
 782             ('section3', [
 783                 ('key1', 'value1'),
 784                 ('key2', 'value2'),
 785                 ('key3', 'value3'),
 786             ]),
 787             ('core 4', [
 788                 ('index', 7),
 789                 ('mode', 'gen'),
 790                 ('name', 'udp'),
 791             ]),
 792         ]
 793
 794         result = setup_helper.global_section
 795         self.assertEqual(result, global_section[1])
 796
 797     def test_find_in_section(self):
 798         setup_helper = ProxDpdkVnfSetupEnvHelper(mock.MagicMock(), mock.MagicMock(),
 799                                                  mock.MagicMock())
 800
 801         setup_helper._prox_config_data = [
 802             ('global', [
 803                 ('not_name', 'other data'),
 804                 ('name_not', 'more data'),
 805                 ('name', 'prox type'),
 806             ]),
 807             ('section1', []),
 808             ('section2', [
 809                 ('a', 'b'),
 810                 ('c', 'd'),
 811             ]),
 812             ('core 1', []),
 813             ('core 2', [
 814                 ('index', 8),
 815                 ('mode', ''),
 816             ]),
 817             ('core 3', [
 818                 ('index', 5),
 819                 ('mode', 'gen'),
 820                 ('name', 'tagged'),
 821             ]),
 822             ('section3', [
 823                 ('key1', 'value1'),
 824                 ('key2', 'value2'),
 825                 ('key3', 'value3'),
 826             ]),
 827             ('core 4', [
 828                 ('index', 7),
 829                 ('mode', 'gen'),
 830                 ('name', 'udp'),
 831             ]),
 832         ]
 833
 834         expected = 'value3'
 835         result = setup_helper.find_in_section('section3', 'key3')
 836         self.assertEqual(result, expected)
 837
 838         expected = 'default value'
 839         result = setup_helper.find_in_section('section3', 'key4', 'default value')
 840         self.assertEqual(result, expected)
 841
 842         with self.assertRaises(KeyError):
 843             setup_helper.find_in_section('section4', 'key1')
 844
 845         with self.assertRaises(KeyError):
 846             setup_helper.find_in_section('section1', 'key1')
 847
 848     def test__replace_quoted_with_value(self):
 849         # empty string
 850         input_str = ''
 851         expected = ''
 852         result = ProxDpdkVnfSetupEnvHelper._replace_quoted_with_value(input_str, 'cat')
 853         self.assertEqual(result, expected)
 854
 855         # no quoted substring
 856         input_str = 'lion tiger bear'
 857         expected = 'lion tiger bear'
 858         result = ProxDpdkVnfSetupEnvHelper._replace_quoted_with_value(input_str, 'cat')
 859         self.assertEqual(result, expected)
 860
 861         # partially quoted substring
 862         input_str = 'lion "tiger bear'
 863         expected = 'lion "tiger bear'
 864         result = ProxDpdkVnfSetupEnvHelper._replace_quoted_with_value(input_str, 'cat')
 865         self.assertEqual(result, expected)
 866
 867         # one quoted substring
 868         input_str = 'lion "tiger" bear'
 869         expected = 'lion "cat" bear'
 870         result = ProxDpdkVnfSetupEnvHelper._replace_quoted_with_value(input_str, 'cat')
 871         self.assertEqual(result, expected)
 872
 873         # two quoted substrings
 874         input_str = 'lion "tiger" bear "shark" whale'
 875         expected = 'lion "cat" bear "shark" whale'
 876         result = ProxDpdkVnfSetupEnvHelper._replace_quoted_with_value(input_str, 'cat')
 877         self.assertEqual(result, expected)
 878
 879         # two quoted substrings, both replaced
 880         input_str = 'lion "tiger" bear "shark" whale'
 881         expected = 'lion "cat" bear "cat" whale'
 882         result = ProxDpdkVnfSetupEnvHelper._replace_quoted_with_value(input_str, 'cat', 2)
 883         self.assertEqual(result, expected)
 884
 885     def test__get_tx_port(self):
 886         # no data
 887         input_data = {'section1': []}
 888         expected = -1
 889         result = ProxDpdkVnfSetupEnvHelper._get_tx_port('section1', input_data)
 890         self.assertEqual(result, expected)
 891
 892         # data for other section
 893         input_data = {
 894             'section1': [],
 895             'section2': [
 896                 ('rx port', '3'),
 897                 ('tx port', '4'),
 898             ],
 899         }
 900         expected = -1
 901         result = ProxDpdkVnfSetupEnvHelper._get_tx_port('section1', input_data)
 902         self.assertEqual(result, expected)
 903
 904         # data for section
 905         input_data['section1'] = section1 = [
 906             ('rx port', '4', 'more', 432),
 907             ('tx port', '3'),
 908         ]
 909         expected = 3
 910         result = ProxDpdkVnfSetupEnvHelper._get_tx_port('section1', input_data)
 911         self.assertEqual(result, expected)
 912
 913         # more data for section,
 914         section1.extend([
 915             ('rx port', '2'),
 916             ('tx port', '1', 'and more', 234),
 917         ])
 918         expected = 1
 919         result = ProxDpdkVnfSetupEnvHelper._get_tx_port('section1', input_data)
 920         self.assertEqual(result, expected)
 921
 922     def test_write_prox_config(self):
 923         input_data = {}
 924         expected = ''
 925         result = ProxDpdkVnfSetupEnvHelper.write_prox_config(input_data)
 926         self.assertEqual(result, expected)
 927
 928         input_data = [
 929             [
 930                 'section1',
 931                 [],
 932             ],
 933         ]
 934         expected = '[section1]'
 935         result = ProxDpdkVnfSetupEnvHelper.write_prox_config(input_data)
 936         self.assertEqual(result, expected)
 937
 938         input_data = [
 939             [
 940                 'section1',
 941                 [],
 942             ],
 943             [
 944                 'section2',
 945                 [
 946                     ['key1', 'value1'],
 947                     ['__name__', 'not this one'],
 948                     ['key2', None],
 949                     ['key3', 234],
 950                     ['key4', 'multi-line\nvalue'],
 951                 ],
 952             ],
 953         ]
 954         expected = os.linesep.join([
 955             '[section1]',
 956             '[section2]',
 957             'key1=value1',
 958             'key2',
 959             'key3=234',
 960             'key4=multi-line\n\tvalue',
 961         ])
 962         result = ProxDpdkVnfSetupEnvHelper.write_prox_config(input_data)
 963         self.assertEqual(result, expected)
 964
 965     def test_prox_config_data(self):
 966         setup_helper = ProxDpdkVnfSetupEnvHelper(mock.MagicMock(), mock.MagicMock(),
 967                                                  mock.MagicMock())
 968
 969         setup_helper.config_queue = config_queue = mock.MagicMock()
 970         config_queue.get.return_value = expected = [('s', [('a', 3), ('b', 45)])]
 971
 972         result = setup_helper.prox_config_data
 973         self.assertEqual(result, expected)
 974
 975     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.find_relative_file')
 976     def test_build_config_file_no_additional_file(self, mock_find_path):
 977         vnf1 = {
 978             'prox_args': {'-c': ""},
 979             'prox_path': 'd',
 980             'prox_config': 'e/f',
 981         }
 982
 983         mock_find_path.side_effect = ['1', '2']
 984
 985         vnfd_helper = mock.MagicMock()
 986         ssh_helper = mock.MagicMock()
 987         scenario_helper = ScenarioHelper('vnf1')
 988         scenario_helper.scenario_cfg = {
 989             'task_path': 'a/b',
 990             'options': {
 991                 'vnf1': vnf1,
 992             },
 993         }
 994
 995         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
 996         helper.copy_to_target = mock.MagicMock(return_value='3')
 997         helper.generate_prox_config_file = mock.MagicMock(return_value='4')
 998         helper.upload_prox_config = mock.MagicMock(return_value='5')
 999
1000         self.assertEqual(helper.additional_files, {})
1001         self.assertNotEqual(helper._prox_config_data, '4')
1002         self.assertNotEqual(helper.remote_path, '5')
1003         helper.build_config_file()
1004         self.assertEqual(helper.additional_files, {})
1005         self.assertEqual(helper._prox_config_data, '4')
1006         self.assertEqual(helper.remote_path, '5')
1007
1008     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.find_relative_file')
1009     def test_build_config_file_additional_file_string(self, mock_find_path):
1010         vnf1 = {
1011             'prox_args': {'-c': ""},
1012             'prox_path': 'd',
1013             'prox_config': 'e/f',
1014             'prox_files': 'g/h.i',
1015         }
1016
1017         mock_find_path.side_effect = ['1', '2']
1018         vnfd_helper = mock.MagicMock()
1019         ssh_helper = mock.MagicMock()
1020         scenario_helper = ScenarioHelper('vnf1')
1021         scenario_helper.scenario_cfg = {
1022             'task_path': 'a/b',
1023             'options': {
1024                 'vnf1': vnf1,
1025             },
1026         }
1027
1028         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1029         helper.copy_to_target = mock.MagicMock(side_effect=['33', '34', '35'])
1030         helper.generate_prox_config_file = mock.MagicMock(return_value='44')
1031         helper.upload_prox_config = mock.MagicMock(return_value='55')
1032
1033         self.assertEqual(helper.additional_files, {})
1034         expected = {'h.i': '33'}
1035         helper.build_config_file()
1036         self.assertDictEqual(helper.additional_files, expected)
1037
1038     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.find_relative_file')
1039     def test_build_config_file_additional_file(self, mock_find_path):
1040         vnf1 = {
1041             'prox_args': {'-c': ""},
1042             'prox_path': 'd',
1043             'prox_config': 'e/f',
1044             'prox_files': [
1045                 'g/h.i',
1046                 'j/k/l',
1047                 'm_n',
1048             ],
1049         }
1050
1051         mock_find_path.side_effect = ['1', '2'] + [str(i) for i in range(len(vnf1['prox_files']))]
1052         vnfd_helper = mock.MagicMock()
1053         ssh_helper = mock.MagicMock()
1054         scenario_helper = ScenarioHelper('vnf1')
1055         scenario_helper.scenario_cfg = {
1056             'task_path': 'a/b',
1057             'options': {
1058                 'vnf1': vnf1,
1059             },
1060         }
1061
1062         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1063         helper.copy_to_target = mock.MagicMock(side_effect=['33', '34', '35'])
1064         helper.generate_prox_config_file = mock.MagicMock(return_value='44')
1065         helper.upload_prox_config = mock.MagicMock(return_value='55')
1066
1067         self.assertEqual(helper.additional_files, {})
1068         self.assertNotEqual(helper._prox_config_data, '44')
1069         self.assertNotEqual(helper.remote_path, '55')
1070         expected = {'h.i': '33', 'l': '34', 'm_n': '35'}
1071         helper.build_config_file()
1072         self.assertDictEqual(helper.additional_files, expected)
1073         self.assertEqual(helper._prox_config_data, '44')
1074         self.assertEqual(helper.remote_path, '55')
1075
1076     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.find_relative_file')
1077     def test_build_config(self, mock_find_path):
1078         vnf1 = {
1079             'prox_args': {'-f': ""},
1080             'prox_path': '/opt/nsb_bin/prox',
1081             'prox_config': 'configs/gen_l2fwd-2.cfg',
1082             'prox_files': [
1083                 'g/h.i',
1084                 'j/k/l',
1085                 'm_n',
1086             ],
1087         }
1088
1089         mock_find_path.side_effect = ['1', '2']
1090         vnfd_helper = mock.MagicMock()
1091         ssh_helper = mock.MagicMock()
1092         ssh_helper.provision_tool.return_value = "/opt/nsb_bin/prox"
1093         scenario_helper = ScenarioHelper('vnf1')
1094         scenario_helper.scenario_cfg = {
1095             'task_path': 'a/b',
1096             'options': {
1097                 'vnf1': vnf1,
1098             },
1099         }
1100
1101         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1102         helper.remote_path = "/tmp/prox.cfg"
1103         expected = "sudo bash -c 'cd /opt/nsb_bin; /opt/nsb_bin/prox -o cli -f  -f /tmp/prox.cfg '"
1104         with mock.patch.object(helper, "build_config_file") as mock_build_config:
1105             prox_cmd = helper.build_config()
1106             self.assertEqual(prox_cmd, expected)
1107
1108     def test__insert_additional_file(self):
1109         vnfd_helper = mock.MagicMock()
1110         ssh_helper = mock.MagicMock()
1111         scenario_helper = mock.MagicMock()
1112
1113         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1114         helper.additional_files = {"ipv4.lua": "/tmp/ipv4.lua"}
1115         res = helper._insert_additional_file('dofile("ipv4.lua")')
1116         self.assertEqual(res, 'dofile("/tmp/ipv4.lua")')
1117
1118     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ConfigParser')
1119     def test_generate_prox_config_file(self, mock_parser_type):
1120         def init(*args):
1121             if sections_data:
1122                 args[-1].extend(sections_data)
1123             return mock.MagicMock()
1124
1125         sections_data = []
1126
1127         mock_parser_type.side_effect = init
1128
1129         vnfd_helper = VnfdHelper(self.VNFD0)
1130         ssh_helper = mock.MagicMock()
1131         scenario_helper = mock.MagicMock()
1132
1133         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1134         helper.additional_files = {}
1135
1136         expected = []
1137         result = helper.generate_prox_config_file('a/b')
1138         self.assertEqual(result, expected)
1139
1140         helper.additional_files = {"ipv4.lua": "/tmp/ipv4.lua"}
1141
1142         helper.remote_prox_file_name = 'remote'
1143         sections_data = [
1144             [
1145                 'lua',
1146                 [
1147                     ['dofile("ipv4.lua")', ''],
1148                 ],
1149             ],
1150             [
1151                 'port 0',
1152                 [
1153                     ['ip', ''],
1154                     ['mac', 'foo'],
1155                     ['dst mac', '@@1'],
1156                     ['tx port', '1'],
1157                 ],
1158             ],
1159             [
1160                 'port 2',
1161                 [
1162                     ['ip', ''],
1163                     ['$sut_mac0', '@@dst_mac0'],
1164                     ['tx port', '0'],
1165                     ['single', '@'],
1166                     ['user_table', 'dofile("ipv4.lua")'],
1167                     ['missing_addtional_file', 'dofile("nosuch")'],
1168                 ],
1169             ],
1170         ]
1171
1172         expected = [
1173             [
1174                 'lua',
1175                 [
1176                     ['dofile("/tmp/ipv4.lua")', ''],
1177                 ],
1178             ],
1179             [
1180                 'port 0',
1181                 [
1182                     ['ip', ''],
1183                     ['mac', 'hardware'],
1184                     ['dst mac', '00:00:00:00:00:03'],
1185                     ['tx port', '1'],
1186                 ],
1187             ],
1188             [
1189                 'port 2',
1190                 [
1191                     ['ip', ''],
1192                     ['$sut_mac0', '00 00 00 00 00 04'],
1193                     ['tx port', '0'],
1194                     ['single', '@'],
1195                     ['user_table', 'dofile("/tmp/ipv4.lua")'],
1196                     ['missing_addtional_file', 'dofile("nosuch")'],
1197                 ],
1198             ],
1199         ]
1200         result = helper.generate_prox_config_file('/c/d/e')
1201         self.assertEqual(result, expected, str(result))
1202
1203     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ConfigParser')
1204     def test_generate_prox_config_file_negative(self, mock_parser_type):
1205         def init(*args):
1206             args[-1].update(sections_data)
1207             return mock.MagicMock()
1208
1209         sections_data = {}
1210
1211         mock_parser_type.side_effect = init
1212
1213         vnfd_helper = mock.MagicMock()
1214         vnfd_helper.interfaces = []
1215         ssh_helper = mock.MagicMock()
1216         scenario_helper = mock.MagicMock()
1217
1218         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1219         helper.additional_files = {}
1220         helper.remote_prox_file_name = 'remote'
1221         vnfd_helper.interfaces = [
1222             {
1223                 'virtual-interface': {
1224                     'dpdk_port_num': 3,
1225                     'dst_mac': '00:00:00:de:ad:88',
1226                 },
1227             },
1228             {
1229                 'virtual-interface': {
1230                     'dpdk_port_num': 5,
1231                     'dst_mac': '00:00:00:de:ad:ff',
1232                 },
1233             },
1234             {
1235                 'virtual-interface': {
1236                     'dpdk_port_num': 7,
1237                     'dst_mac': '00:00:00:de:ad:ff',
1238                 },
1239             },
1240         ]
1241         sections_data = {
1242             'port 3': [
1243                 ['ip', ''],
1244                 ['mac', 'foo'],
1245                 ['dst mac', ''],
1246             ],
1247             'port 5': [
1248                 ['ip', ''],
1249                 ['dst mac', ''],
1250                 ['tx port', '0'],
1251                 ['???', 'dofile "here" 23'],
1252             ],
1253         }
1254
1255         with self.assertRaises(Exception):
1256             helper.generate_prox_config_file('a/b')
1257
1258     def test_generate_prox_lua_file(self):
1259         vnfd_helper = VnfdHelper(self.VNFD0)
1260         ssh_helper = mock.MagicMock()
1261         scenario_helper = mock.MagicMock()
1262
1263         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1264         helper.LUA_PARAMETER_NAME = 'sut'
1265
1266         expected = [
1267             'sut_hex_ip_port_0:"98 10 64 13"',
1268             'sut_ip_port_0:"152.16.100.19"',
1269             'gen_hex_ip_port_0:"98 10 64 13"',
1270             'gen_ip_port_0:"152.16.100.19"',
1271
1272             'sut_hex_ip_port_1:"98 10 28 13"',
1273             'sut_ip_port_1:"152.16.40.19"',
1274             'gen_hex_ip_port_1:"98 10 28 14"',
1275             'gen_ip_port_1:"152.16.40.20"',
1276         ]
1277         result = helper.generate_prox_lua_file()
1278         self.assertListEqual(result.splitlines(), expected)
1279
1280     def test_upload_prox_lua(self):
1281         def identity(*args):
1282             return args
1283
1284         vnfd_helper = mock.MagicMock()
1285         vnfd_helper.interfaces = []
1286         ssh_helper = mock.MagicMock()
1287         scenario_helper = mock.MagicMock()
1288
1289         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1290         helper.generate_prox_lua_file = mock.MagicMock(return_value=234)
1291         helper.put_string_to_file = identity
1292
1293         expected = ''
1294         result = helper.upload_prox_lua('my_dir', {})
1295         self.assertEqual(result, expected)
1296
1297         input_data = {
1298             'lua': {
1299                 'key1': 'value1 ("inside") tail',
1300                 'key2': 'value2',
1301                 'key3 ("key_side") head': 'value3',
1302             },
1303         }
1304
1305         expected = 234, 'my_dir/key_side'
1306         result = helper.upload_prox_lua('my_dir', input_data)
1307         self.assertEqual(result, expected)
1308
1309     def test_put_string_to_file(self):
1310         vnfd_helper = mock.MagicMock()
1311         vnfd_helper.interfaces = []
1312         ssh_helper = mock.MagicMock()
1313         scenario_helper = mock.MagicMock()
1314
1315         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1316
1317         expected = 'a/b'
1318         result = helper.put_string_to_file('my long string', 'a/b')
1319         self.assertEqual(result, expected)
1320
1321     def test__build_pipeline_kwarags(self):
1322         vnfd_helper = mock.MagicMock()
1323         ssh_helper = mock.MagicMock()
1324         ssh_helper.provision_tool.return_value = "/tmp/nosuch"
1325         scenario_helper = mock.MagicMock()
1326
1327         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1328         helper._build_pipeline_kwargs()
1329         self.assertEqual(helper.pipeline_kwargs, {'tool_path': '/tmp/nosuch', 'tool_dir': '/tmp'})
1330
1331     def test_copy_to_target(self):
1332         vnfd_helper = mock.MagicMock()
1333         vnfd_helper.interfaces = []
1334         ssh_helper = mock.MagicMock()
1335         scenario_helper = mock.MagicMock()
1336
1337         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1338         expected = '/tmp/c'
1339         result = helper.copy_to_target('a/b', 'c')
1340         self.assertEqual(result, expected)
1341
1342     def test_upload_prox_config(self):
1343         vnfd_helper = mock.MagicMock()
1344         vnfd_helper.interfaces = []
1345         ssh_helper = mock.MagicMock()
1346         scenario_helper = mock.MagicMock()
1347
1348         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1349         helper.write_prox_config = mock.MagicMock(return_value='a long string')
1350         expected = '/tmp/a'
1351         result = helper.upload_prox_config('a', {})
1352         self.assertEqual(result, expected)
1353
1354
1355 class TestProxResourceHelper(unittest.TestCase):
1356
1357     VNFD0 = {
1358         'short-name': 'ProxVnf',
1359         'vdu': [
1360             {
1361                 'routing_table': [
1362                     {
1363                         'network': '152.16.100.20',
1364                         'netmask': '255.255.255.0',
1365                         'gateway': '152.16.100.20',
1366                         'if': 'xe0',
1367                     },
1368                     {
1369                         'network': '152.16.40.20',
1370                         'netmask': '255.255.255.0',
1371                         'gateway': '152.16.40.20',
1372                         'if': 'xe1',
1373                     },
1374                 ],
1375                 'description': 'PROX approximation using DPDK',
1376                 'name': 'proxvnf-baremetal',
1377                 'nd_route_tbl': [
1378                     {
1379                         'network': '0064:ff9b:0:0:0:0:9810:6414',
1380                         'netmask': '112',
1381                         'gateway': '0064:ff9b:0:0:0:0:9810:6414',
1382                         'if': 'xe0',
1383                     },
1384                     {
1385                         'network': '0064:ff9b:0:0:0:0:9810:2814',
1386                         'netmask': '112',
1387                         'gateway': '0064:ff9b:0:0:0:0:9810:2814',
1388                         'if': 'xe1',
1389                     },
1390                 ],
1391                 'id': 'proxvnf-baremetal',
1392                 'external-interface': [
1393                     {
1394                         'virtual-interface': {
1395                             'dst_mac': '00:00:00:00:00:04',
1396                             'vpci': '0000:05:00.0',
1397                             'local_ip': '152.16.100.19',
1398                             'type': 'PCI-PASSTHROUGH',
1399                             'vld_id': 'uplink_0',
1400                             'netmask': '255.255.255.0',
1401                             'dpdk_port_num': 0,
1402                             'bandwidth': '10 Gbps',
1403                             'driver': "i40e",
1404                             'dst_ip': '152.16.100.19',
1405                             'local_iface_name': 'xe0',
1406                             'local_mac': '00:00:00:00:00:02',
1407                             'ifname': 'xe0',
1408                         },
1409                         'vnfd-connection-point-ref': 'xe0',
1410                         'name': 'xe0',
1411                     },
1412                     {
1413                         'virtual-interface': {
1414                             'dst_mac': '00:00:00:00:00:03',
1415                             'vpci': '0000:05:00.1',
1416                             'local_ip': '152.16.40.19',
1417                             'type': 'PCI-PASSTHROUGH',
1418                             'vld_id': 'downlink_0',
1419                             'driver': "i40e",
1420                             'netmask': '255.255.255.0',
1421                             'dpdk_port_num': 1,
1422                             'bandwidth': '10 Gbps',
1423                             'dst_ip': '152.16.40.20',
1424                             'local_iface_name': 'xe1',
1425                             'local_mac': '00:00:00:00:00:01',
1426                             'ifname': 'xe1',
1427                         },
1428                         'vnfd-connection-point-ref': 'xe1',
1429                         'name': 'xe1',
1430                     },
1431                 ],
1432             },
1433         ],
1434         'description': 'PROX approximation using DPDK',
1435         'mgmt-interface': {
1436             'vdu-id': 'proxvnf-baremetal',
1437             'host': '1.2.1.1',
1438             'password': 'r00t',
1439             'user': 'root',
1440             'ip': '1.2.1.1',
1441         },
1442         'benchmark': {
1443             'kpi': [
1444                 'packets_in',
1445                 'packets_fwd',
1446                 'packets_dropped',
1447             ],
1448         },
1449         'id': 'ProxApproxVnf',
1450         'name': 'ProxVnf',
1451     }
1452
1453     VNFD = {
1454         'vnfd:vnfd-catalog': {
1455             'vnfd': [
1456                 VNFD0,
1457             ],
1458         },
1459     }
1460
1461     def test_find_pci(self):
1462         input_str_list = [
1463             'no target here',
1464             'nor here',
1465             'and still not',
1466         ]
1467         result = ProxResourceHelper.find_pci('target', input_str_list)
1468         self.assertFalse(result)
1469
1470         input_str_list = [
1471             'no target here',
1472             'nor here',
1473             'this is a target',
1474             'did we miss it',
1475         ]
1476         result = ProxResourceHelper.find_pci('target', input_str_list)
1477         self.assertTrue(result)
1478
1479     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.RETRY_INTERVAL', 0)
1480     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ProxSocketHelper')
1481     def test_sut(self, mock_socket_helper):
1482         helper = ProxResourceHelper(mock.MagicMock())
1483         self.assertIsNone(helper.client)
1484         result = helper.sut
1485         self.assertIsNotNone(result)
1486         self.assertIs(result, helper.client)
1487         self.assertIs(result, helper.sut)
1488
1489     def test_test_type(self):
1490         setup_helper = mock.MagicMock()
1491         setup_helper.find_in_section.return_value = expected = 'prox type'
1492
1493         helper = ProxResourceHelper(setup_helper)
1494
1495         self.assertIsNone(helper._test_type)
1496         self.assertEqual(helper.test_type, expected)
1497         self.assertEqual(helper._test_type, expected)
1498         self.assertEqual(helper.test_type, expected)
1499
1500     def test_collect_collectd_kpi(self):
1501         helper = ProxResourceHelper(mock.MagicMock())
1502         helper.resource = resource = mock.MagicMock()
1503
1504         resource.amqp_collect_nfvi_kpi.return_value = 543
1505
1506         expected = {'core': 543}
1507         result = helper.collect_collectd_kpi()
1508         self.assertDictEqual(result, expected)
1509
1510     def test_collect_kpi(self):
1511         helper = ProxResourceHelper(mock.MagicMock())
1512         helper._queue = queue = mock.MagicMock()
1513         helper._result = {'z': 123}
1514         helper.resource = resource = mock.MagicMock()
1515
1516         resource.amqp_collect_nfvi_kpi.return_value = 543
1517
1518         queue.empty.return_value = False
1519         queue.get.return_value = {'a': 789}
1520
1521         expected = {'z': 123, 'a': 789, 'collect_stats': {'core': 543}}
1522         result = helper.collect_kpi()
1523         self.assertDictEqual(result, expected)
1524
1525     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
1526     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ProxSocketHelper')
1527     def test__connect(self, mock_socket_helper_type, mock_time):
1528         client = mock_socket_helper_type()
1529         client.connect.side_effect = chain(repeat(socket.error, 5), [None])
1530
1531         setup_helper = mock.MagicMock()
1532         setup_helper.vnfd_helper.interfaces = []
1533
1534         helper = ProxResourceHelper(setup_helper)
1535
1536         result = helper._connect()
1537         self.assertIs(result, client)
1538
1539         client.connect.side_effect = chain(repeat(socket.error, 65), [None])
1540
1541         with self.assertRaises(Exception):
1542             helper._connect()
1543
1544     def test_run_traffic(self):
1545         setup_helper = mock.MagicMock()
1546         helper = ProxResourceHelper(setup_helper)
1547         traffic_profile = mock.MagicMock(**{"done": True})
1548         helper.run_traffic(traffic_profile)
1549         self.assertEqual(helper._terminated.value, 1)
1550
1551     def test__run_traffic_once(self):
1552         setup_helper = mock.MagicMock()
1553         helper = ProxResourceHelper(setup_helper)
1554         traffic_profile = mock.MagicMock(**{"done": True})
1555         helper._run_traffic_once(traffic_profile)
1556         self.assertEqual(helper._terminated.value, 1)
1557
1558     def test_start_collect(self):
1559         setup_helper = mock.MagicMock()
1560         helper = ProxResourceHelper(setup_helper)
1561         helper.resource = resource = mock.MagicMock()
1562         self.assertIsNone(helper.start_collect())
1563         resource.start.assert_called_once()
1564
1565     def test_terminate(self):
1566         setup_helper = mock.MagicMock()
1567         helper = ProxResourceHelper(setup_helper)
1568         with self.assertRaises(NotImplementedError):
1569             helper.terminate()
1570
1571     def test_up_post(self):
1572         setup_helper = mock.MagicMock()
1573         helper = ProxResourceHelper(setup_helper)
1574         helper.client = expected = mock.MagicMock()
1575         result = helper.up_post()
1576         self.assertEqual(result, expected)
1577
1578     def test_execute(self):
1579         setup_helper = mock.MagicMock()
1580         helper = ProxResourceHelper(setup_helper)
1581         helper.client = mock.MagicMock()
1582
1583         expected = helper.client.my_command()
1584         result = helper.execute('my_command')
1585         self.assertEqual(result, expected)
1586
1587         helper.client = object()
1588
1589         result = helper.execute('my_command')
1590         self.assertIsNone(result)
1591
1592
1593 class TestProxDataHelper(unittest.TestCase):
1594
1595     def test_totals_and_pps(self):
1596         pkt_size = 180
1597         vnfd_helper = mock.MagicMock()
1598         vnfd_helper.port_pairs.all_ports = list(range(4))
1599
1600         sut = mock.MagicMock()
1601         sut.port_stats.return_value = list(range(10))
1602
1603         data_helper = ProxDataHelper(vnfd_helper, sut, pkt_size, 25, None)
1604
1605         self.assertEqual(data_helper.rx_total, 6)
1606         self.assertEqual(data_helper.tx_total, 7)
1607         self.assertEqual(data_helper.pps, 6.25e6)
1608
1609     def test_samples(self):
1610         vnfd_helper = mock.MagicMock()
1611         vnfd_helper.port_pairs.all_ports = list(range(4))
1612         vnfd_helper.ports_iter.return_value = [('xe1', 3), ('xe2', 7)]
1613
1614         sut = mock.MagicMock()
1615         sut.port_stats.return_value = list(range(10))
1616
1617         data_helper = ProxDataHelper(vnfd_helper, sut, None, None, None)
1618
1619         expected = {
1620             'xe1': {
1621                 'in_packets': 6,
1622                 'out_packets': 7,
1623             },
1624             'xe2': {
1625                 'in_packets': 6,
1626                 'out_packets': 7,
1627             },
1628         }
1629         result = data_helper.samples
1630         self.assertDictEqual(result, expected)
1631
1632     def test___enter__(self):
1633         vnfd_helper = mock.MagicMock()
1634         vnfd_helper.port_pairs.all_ports = list(range(4))
1635         vnfd_helper.ports_iter.return_value = [('xe1', 3), ('xe2', 7)]
1636
1637         sut = mock.MagicMock()
1638         sut.port_stats.return_value = list(range(10))
1639
1640         data_helper = ProxDataHelper(vnfd_helper, sut, None, None, 5.4)
1641         data_helper._totals_and_pps = 12, 32, 4.5
1642         data_helper.tsc_hz = 9.8
1643         data_helper.measured_stats = {'delta': TotStatsTuple(6.1, 6.2, 6.3, 6.4)}
1644         data_helper.latency = 7
1645
1646         self.assertIsNone(data_helper.result_tuple)
1647
1648         expected = ProxTestDataTuple(5.4, 9.8, 6.1, 6.2, 6.3, 7, 12, 32, 4.5)
1649         with data_helper:
1650             pass
1651
1652         result = data_helper.result_tuple
1653         self.assertEqual(result, expected)
1654
1655         data_helper.make_tuple()
1656         self.assertIs(data_helper.result_tuple, result)
1657
1658     def test___enter___negative(self):
1659         vnfd_helper = mock.MagicMock()
1660
1661         data_helper = ProxDataHelper(vnfd_helper, None, None, None, None)
1662
1663         vnfd_helper.port_pairs.all_ports = []
1664         with self.assertRaises(AssertionError):
1665             with data_helper:
1666                 pass
1667
1668         vnfd_helper.port_pairs.all_ports = [0, 1, 2]
1669         with self.assertRaises(AssertionError):
1670             with data_helper:
1671                 pass
1672
1673     def test_measure_tot_stats(self):
1674         vnfd_helper = mock.MagicMock()
1675         vnfd_helper.port_pairs.all_ports = list(range(4))
1676
1677         start = (3, 4, 1, 2)
1678         end = (9, 7, 6, 8)
1679
1680         sut = ProxSocketHelper(mock.MagicMock())
1681         sut.get_all_tot_stats = mock.MagicMock(side_effect=[start, end])
1682
1683         data_helper = ProxDataHelper(vnfd_helper, sut, None, None, 5.4)
1684
1685         self.assertIsNone(data_helper.measured_stats)
1686
1687         expected = {
1688             'start_tot': start,
1689             'end_tot': end,
1690             'delta': TotStatsTuple(6, 3, 5, 6),
1691         }
1692         with data_helper.measure_tot_stats():
1693             pass
1694
1695         self.assertEqual(data_helper.measured_stats, expected)
1696
1697     def test_capture_tsc_hz(self):
1698         vnfd_helper = mock.MagicMock()
1699         vnfd_helper.port_pairs.all_ports = list(range(4))
1700
1701         sut = mock.MagicMock()
1702         sut.hz.return_value = '54.6'
1703
1704         data_helper = ProxDataHelper(vnfd_helper, sut, None, None, None)
1705
1706         self.assertIsNone(data_helper.tsc_hz)
1707
1708         expected = 54.6
1709         data_helper.capture_tsc_hz()
1710         self.assertEqual(data_helper.tsc_hz, expected)
1711
1712
1713 class TestProxProfileHelper(unittest.TestCase):
1714
1715     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.utils')
1716     def test_get_cls(self, mock_utils):
1717         mock_type1 = mock.MagicMock()
1718         mock_type1.__prox_profile_type__ = 'another_type'
1719         mock_type2 = mock.MagicMock()
1720         mock_type2.__prox_profile_type__ = 'my_type'
1721         mock_utils.itersubclasses.return_value = [mock_type1, mock_type2]
1722
1723         self.assertEqual(ProxProfileHelper.get_cls('my_type'), mock_type2)
1724
1725     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.utils')
1726     def test_get_cls_default(self, mock_utils):
1727         mock_utils.itersubclasses.return_value = []
1728         ProxProfileHelper.get_cls('my_type')
1729
1730     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.SocketTopology')
1731     def test_cpu_topology(self, mock_socket_topology):
1732         mock_socket_topology.parse_cpuinfo.return_value = 432
1733
1734         resource_helper = mock.MagicMock()
1735         resource_helper.setup_helper.ssh_helper.execute.return_value = 0, 'output', ''
1736
1737         helper = ProxProfileHelper(resource_helper)
1738         self.assertIsNone(helper._cpu_topology)
1739         result = helper.cpu_topology
1740         self.assertEqual(result, 432)
1741         self.assertIs(result, helper._cpu_topology)
1742         self.assertIs(result, helper.cpu_topology)
1743
1744     def test_test_cores(self):
1745         resource_helper = mock.MagicMock()
1746         resource_helper.setup_helper.prox_config_data = []
1747
1748         helper = ProxProfileHelper(resource_helper)
1749         helper._cpu_topology = []
1750
1751         expected = []
1752         result = helper.test_cores
1753         self.assertEqual(result, expected)
1754
1755         resource_helper.setup_helper.prox_config_data = [
1756             ('section1', []),
1757             ('section2', [
1758                 ('a', 'b'),
1759                 ('c', 'd'),
1760             ]),
1761             ('core 1s3', []),
1762             ('core 2s5', [
1763                 ('index', 8),
1764                 ('mode', ''),
1765             ]),
1766             ('core 3s1', [
1767                 ('index', 5),
1768                 ('mode', 'gen'),
1769             ]),
1770             ('core 4s9h', [
1771                 ('index', 7),
1772                 ('mode', 'gen'),
1773             ]),
1774         ]
1775
1776         helper = ProxProfileHelper(resource_helper)
1777         helper._cpu_topology = {
1778             1: {
1779                 3: {
1780                     'key1': (23, 32),
1781                     'key2': (12, 21),
1782                     'key3': (44, 33),
1783                 },
1784             },
1785             9: {
1786                 4: {
1787                     'key1': (44, 32),
1788                     'key2': (23, 21),
1789                     'key3': (12, 33),
1790                 },
1791             },
1792         }
1793
1794         self.assertIsNone(helper._test_cores)
1795         expected = [12, 23]
1796         result = helper.test_cores
1797         self.assertEqual(result, expected)
1798         self.assertIs(result, helper._test_cores)
1799         self.assertIs(result, helper.test_cores)
1800
1801     def test_latency_cores(self):
1802         resource_helper = mock.MagicMock()
1803         resource_helper.setup_helper.prox_config_data= []
1804
1805         helper = ProxProfileHelper(resource_helper)
1806         helper._cpu_topology = []
1807
1808         expected = []
1809         result = helper.latency_cores
1810         self.assertEqual(result, expected)
1811
1812         resource_helper.setup_helper.prox_config_data = [
1813             ('section1', []),
1814             ('section2', [
1815                 ('a', 'b'),
1816                 ('c', 'd'),
1817             ]),
1818             ('core 1s3', []),
1819             ('core 2s5', [
1820                 ('index', 8),
1821                 ('mode', ''),
1822             ]),
1823             ('core 3s1', [
1824                 ('index', 5),
1825                 ('mode', 'lat'),
1826             ]),
1827             ('core 4s9h', [
1828                 ('index', 7),
1829                 ('mode', 'lat'),
1830             ]),
1831         ]
1832
1833         helper = ProxProfileHelper(resource_helper)
1834         helper._cpu_topology = {
1835             1: {
1836                 3: {
1837                     'key1': (23, 32),
1838                     'key2': (12, 21),
1839                     'key3': (44, 33),
1840                 },
1841             },
1842             9: {
1843                 4: {
1844                     'key1': (44, 32),
1845                     'key2': (23, 21),
1846                     'key3': (12, 33),
1847                 },
1848             },
1849         }
1850
1851         self.assertIsNone(helper._latency_cores)
1852         expected = [12, 23]
1853         result = helper.latency_cores
1854         self.assertEqual(result, expected)
1855         self.assertIs(result, helper._latency_cores)
1856         self.assertIs(result, helper.latency_cores)
1857
1858     def test_all_rx_cores(self):
1859         helper = ProxBngProfileHelper(mock.MagicMock())
1860         helper._latency_cores = expected = [3, 4, 6]
1861         helper._test_cores = [5, 2, 1]
1862
1863         result = helper.all_rx_cores
1864         self.assertEqual(result, expected)
1865
1866     def test_get_cores(self):
1867         resource_helper = mock.MagicMock()
1868         resource_helper.setup_helper.prox_config_data = [
1869             ('section1', []),
1870             ('section2', [
1871                 ('a', 'b'),
1872                 ('c', 'd'),
1873             ]),
1874             ('core 1', []),
1875             ('core 2', [
1876                 ('index', 8),
1877                 ('mode', ''),
1878             ]),
1879             ('core 3', [
1880                 ('index', 5),
1881                 ('mode', 'gen'),
1882             ]),
1883             ('core 4', [
1884                 ('index', 7),
1885                 ('mode', 'gen'),
1886             ]),
1887         ]
1888
1889         helper = ProxProfileHelper(resource_helper)
1890         helper._cpu_topology = {
1891             0: {
1892                 1: {
1893                     5: (5, 1, 0)
1894                 },
1895                 2: {
1896                     6: (6, 2, 0)
1897                 },
1898                 3: {
1899                     7: (7, 3, 0)
1900                 },
1901                 4: {
1902                     8: (8, 3, 0)
1903                 },
1904             }
1905         }
1906
1907         expected = [7, 8]
1908         result = helper.get_cores(helper.PROX_CORE_GEN_MODE)
1909         self.assertEqual(result, expected)
1910
1911     def test_get_latency(self):
1912         resource_helper = mock.MagicMock()
1913         resource_helper.setup_helper.vnfd_helper.interfaces = []
1914
1915         helper = ProxProfileHelper(resource_helper)
1916         helper._latency_cores = []
1917
1918         expected = []
1919         result = helper.get_latency()
1920         self.assertEqual(result, expected)
1921
1922         helper._latency_cores = [1, 2]
1923         helper.client = mock.MagicMock()
1924
1925         expected = helper.sut.lat_stats()
1926         result = helper.get_latency()
1927         self.assertIs(result, expected)
1928
1929     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
1930     def test_traffic_context(self, mock_time):
1931         setup_helper = mock.MagicMock()
1932         setup_helper.vnfd_helper.interfaces = []
1933
1934         helper = ProxProfileHelper(setup_helper)
1935         helper._cpu_topology = {
1936             0: {
1937                 1: {
1938                     5: (5, 1, 0)
1939                 },
1940                 2: {
1941                     6: (6, 2, 0)
1942                 },
1943                 3: {
1944                     7: (7, 3, 0)
1945                 },
1946                 4: {
1947                     8: (8, 3, 0)
1948                 },
1949             }
1950         }
1951
1952         setup_helper.prox_config_data = [
1953             ('global', [
1954                 ('not_name', 'other data'),
1955                 ('name_not', 'more data'),
1956                 ('name', helper.__prox_profile_type__),
1957             ]),
1958             ('section1', []),
1959             ('section2', [
1960                 ('a', 'b'),
1961                 ('c', 'd'),
1962             ]),
1963             ('core 1', []),
1964             ('core 2', [
1965                 ('index', 8),
1966                 ('mode', ''),
1967             ]),
1968             ('core 3', [
1969                 ('index', 5),
1970                 ('mode', 'gen'),
1971                 ('name', 'tagged'),
1972             ]),
1973             ('core 4', [
1974                 ('index', 7),
1975                 ('mode', 'gen'),
1976                 ('name', 'udp'),
1977             ]),
1978         ]
1979
1980
1981         client = mock.MagicMock()
1982         client.hz.return_value = 2
1983         client.port_stats.return_value = tuple(range(12))
1984
1985         helper.client = client
1986         helper.get_latency = mock.MagicMock(return_value=[3.3, 3.6, 3.8])
1987
1988         helper._test_cores = [3, 4]
1989
1990         with helper.traffic_context(64, 1):
1991             pass
1992
1993     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
1994     def test_run_test(self, _):
1995         resource_helper = mock.MagicMock()
1996         resource_helper.step_delta = 0.4
1997         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
1998         resource_helper.sut.port_stats.return_value = list(range(10))
1999
2000         helper = ProxProfileHelper(resource_helper)
2001
2002         helper.run_test(120, 5, 6.5)
2003
2004
2005 class TestProxMplsProfileHelper(unittest.TestCase):
2006
2007     def test_mpls_cores(self):
2008         resource_helper = mock.MagicMock()
2009         resource_helper.setup_helper.prox_config_data = [
2010             ('section1', []),
2011             ('section2', [
2012                 ('a', 'b'),
2013                 ('c', 'd'),
2014             ]),
2015             ('core 1', []),
2016             ('core 2', [
2017                 ('index', 8),
2018                 ('mode', ''),
2019             ]),
2020             ('core 3', [
2021                 ('index', 5),
2022                 ('mode', 'gen'),
2023                 ('name', 'tagged'),
2024             ]),
2025             ('core 4', [
2026                 ('index', 7),
2027                 ('mode', 'gen'),
2028                 ('name', 'udp'),
2029             ]),
2030         ]
2031
2032         helper = ProxMplsProfileHelper(resource_helper)
2033         helper._cpu_topology = {
2034             0: {
2035                 1: {
2036                     5: (5, 1, 0)
2037                 },
2038                 2: {
2039                     6: (6, 2, 0)
2040                 },
2041                 3: {
2042                     7: (7, 3, 0)
2043                 },
2044                 4: {
2045                     8: (8, 3, 0)
2046                 },
2047             }
2048         }
2049
2050         expected_tagged = [7]
2051         expected_plain = [8]
2052         self.assertIsNone(helper._cores_tuple)
2053         self.assertEqual(helper.tagged_cores, expected_tagged)
2054         self.assertEqual(helper.plain_cores, expected_plain)
2055         self.assertEqual(helper._cores_tuple, (expected_tagged, expected_plain))
2056
2057     def test_traffic_context(self):
2058         setup_helper = mock.MagicMock()
2059         helper = ProxMplsProfileHelper(setup_helper)
2060
2061         with helper.traffic_context(120, 5.4):
2062             pass
2063
2064
2065 class TestProxBngProfileHelper(unittest.TestCase):
2066
2067     def test_bng_cores(self):
2068         resource_helper = mock.MagicMock()
2069         resource_helper.setup_helper.prox_config_data = [
2070             ('section1', []),
2071             ('section2', [
2072                 ('a', 'b'),
2073                 ('c', 'd'),
2074             ]),
2075             ('core 1', []),
2076             ('core 2', [
2077                 ('index', 8),
2078                 ('mode', ''),
2079             ]),
2080             ('core 3', [
2081                 ('index', 5),
2082                 ('mode', 'gen'),
2083                 ('name', 'cpe'),
2084             ]),
2085             ('core 4', [
2086                 ('index', 7),
2087                 ('mode', 'gen'),
2088                 ('name', 'inet'),
2089             ]),
2090             ('core 6', [
2091                 ('index', 3),
2092                 ('mode', 'gen'),
2093                 ('name', 'arp_task'),
2094             ]),
2095             ('core 9', [
2096                 ('index', 2),
2097                 ('mode', 'gen'),
2098                 ('name', 'arp'),
2099             ]),
2100         ]
2101
2102         helper = ProxBngProfileHelper(resource_helper)
2103         helper._cpu_topology = {
2104             0: {
2105                 1: {
2106                     5: (5, 1, 0)
2107                 },
2108                 2: {
2109                     6: (6, 2, 0)
2110                 },
2111                 3: {
2112                     7: (7, 3, 0)
2113                 },
2114                 4: {
2115                     8: (8, 3, 0)
2116                 },
2117                 6: {
2118                     1: (4, 8, 0)
2119                 },
2120                 9: {
2121                     2: (3, 7, 0)
2122                 },
2123             }
2124         }
2125
2126         expected_cpe = [7]
2127         expected_inet = [8]
2128         expected_arp = [4, 3]
2129         expected_arp_task = [0, 4]
2130         expected_combined = (expected_cpe, expected_inet, expected_arp, expected_arp_task)
2131
2132         self.assertIsNone(helper._cores_tuple)
2133         self.assertEqual(helper.cpe_cores, expected_cpe)
2134         self.assertEqual(helper.inet_cores, expected_inet)
2135         self.assertEqual(helper.arp_cores, expected_arp)
2136         self.assertEqual(helper.arp_task_cores, expected_arp_task)
2137         self.assertEqual(helper._cores_tuple, expected_combined)
2138
2139     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
2140     def test_run_test(self, _):
2141         resource_helper = mock.MagicMock()
2142         resource_helper.step_delta = 0.4
2143         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2144         resource_helper.sut.port_stats.return_value = list(range(10))
2145
2146         helper = ProxBngProfileHelper(resource_helper)
2147
2148         helper.run_test(120, 5, 6.5)
2149         helper.run_test(-1000, 5, 6.5)  # negative pkt_size is the only way to make ratio > 1