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