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

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