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

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