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