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