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

   1
   2 # Copyright (c) 2016-2017 Intel Corporation
   3 #
   4 # Licensed under the Apache License, Version 2.0 (the "License");
   5 # you may not use this file except in compliance with the License.
   6 # You may obtain a copy of the License at
   7 #
   8 #      http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 # See the License for the specific language governing permissions and
  14 # limitations under the License.
  15 #
  16
  17 from itertools import repeat, chain
  18 import os
  19 import socket
  20 import time
  21
  22 import mock
  23 import unittest
  24
  25 from tests.unit import STL_MOCKS
  26 from yardstick.common import utils
  27 from yardstick.network_services.vnf_generic.vnf.base import VnfdHelper
  28 from yardstick.network_services import constants
  29
  30 STLClient = mock.MagicMock()
  31 stl_patch = mock.patch.dict("sys.modules", STL_MOCKS)
  32 stl_patch.start()
  33
  34 if stl_patch:
  35     from yardstick.network_services.vnf_generic.vnf.sample_vnf import ScenarioHelper
  36     from yardstick.network_services.vnf_generic.vnf.prox_helpers import ProxSocketHelper
  37     from yardstick.network_services.vnf_generic.vnf.prox_helpers import PacketDump
  38     from yardstick.network_services.vnf_generic.vnf.prox_helpers import CoreSocketTuple
  39     from yardstick.network_services.vnf_generic.vnf.prox_helpers import ProxTestDataTuple
  40     from yardstick.network_services.vnf_generic.vnf.prox_helpers import ProxDpdkVnfSetupEnvHelper
  41     from yardstick.network_services.vnf_generic.vnf.prox_helpers import TotStatsTuple
  42     from yardstick.network_services.vnf_generic.vnf.prox_helpers import ProxDataHelper
  43     from yardstick.network_services.vnf_generic.vnf.prox_helpers import ProxResourceHelper
  44     from yardstick.network_services.vnf_generic.vnf.prox_helpers import ProxProfileHelper
  45     from yardstick.network_services.vnf_generic.vnf.prox_helpers import ProxMplsProfileHelper
  46     from yardstick.network_services.vnf_generic.vnf.prox_helpers import ProxBngProfileHelper
  47     from yardstick.network_services.vnf_generic.vnf.prox_helpers import ProxVpeProfileHelper
  48     from yardstick.network_services.vnf_generic.vnf.prox_helpers import ProxlwAFTRProfileHelper
  49
  50 class TestCoreTuple(unittest.TestCase):
  51     def test___init__(self):
  52         core_tuple = CoreSocketTuple('core 5s6')
  53         self.assertEqual(core_tuple.core_id, 5)
  54         self.assertEqual(core_tuple.socket_id, 6)
  55         self.assertFalse(core_tuple.is_hyperthread())
  56
  57         core_tuple = CoreSocketTuple('core 5s6h')
  58         self.assertEqual(core_tuple.core_id, 5)
  59         self.assertEqual(core_tuple.socket_id, 6)
  60         self.assertTrue(core_tuple.is_hyperthread())
  61
  62     def test___init__negative(self):
  63         bad_inputs = [
  64             '',
  65             '5',
  66             '5s',
  67             '6h',
  68             '5s6',
  69             'core',
  70             'core h',
  71             'core 5s',
  72             'core 5 6',
  73             'core 5 6h',
  74             'core 5d6',
  75             'core 5d6h',
  76             1,
  77             2.3,
  78             [],
  79             {},
  80             object(),
  81         ]
  82
  83         for bad_input in bad_inputs:
  84             with self.assertRaises(ValueError):
  85                 CoreSocketTuple(bad_input)
  86
  87     def test_find_in_topology(self):
  88         topology_in = {
  89             6: {
  90                 5: {
  91                     'key1': ['a', 'b'],
  92                     'key2': ['c', 'd'],
  93                 },
  94             },
  95         }
  96
  97         core_tuple = CoreSocketTuple('core 5s6')
  98
  99         expected = 'a'
 100         result = core_tuple.find_in_topology(topology_in)
 101         self.assertEqual(result, expected)
 102
 103         core_tuple = CoreSocketTuple('core 5s6h')
 104
 105         expected = 'c'
 106         result = core_tuple.find_in_topology(topology_in)
 107         self.assertEqual(result, expected)
 108
 109     def test_find_in_topology_negative(self):
 110         core_tuple = CoreSocketTuple('core 6s5')
 111         with self.assertRaises(ValueError):
 112             # no socket key
 113             core_tuple.find_in_topology({})
 114
 115         with self.assertRaises(ValueError):
 116             # no core key
 117             core_tuple.find_in_topology({5: {}})
 118
 119         with self.assertRaises(ValueError):
 120             # no first value (as needed by non-hyperthread core)
 121             core_tuple.find_in_topology({5: {6: {'key1': []}}})
 122
 123         core_tuple = CoreSocketTuple('core 6s5h')
 124         with self.assertRaises(ValueError):
 125             # no second value (as needed by hyperthread core)
 126             core_tuple.find_in_topology({5: {6: {'key1': ['e']}}})
 127
 128
 129 class TestTotStatsTuple(unittest.TestCase):
 130     def test___new___negative(self):
 131         with self.assertRaises(TypeError):
 132             # no values
 133             TotStatsTuple()
 134
 135         with self.assertRaises(TypeError):
 136             # one, non-integer value
 137             TotStatsTuple('a')
 138
 139         with self.assertRaises(TypeError):
 140             # too many values
 141             TotStatsTuple(3, 4, 5, 6, 7)
 142
 143
 144 class TestProxTestDataTuple(unittest.TestCase):
 145     def test___init__(self):
 146         prox_test_data = ProxTestDataTuple(1, 2, 3, 4, 5, 6, 7, 8, 9)
 147         self.assertEqual(prox_test_data.tolerated, 1)
 148         self.assertEqual(prox_test_data.tsc_hz, 2)
 149         self.assertEqual(prox_test_data.delta_rx, 3)
 150         self.assertEqual(prox_test_data.delta_tx, 4)
 151         self.assertEqual(prox_test_data.delta_tsc, 5)
 152         self.assertEqual(prox_test_data.latency, 6)
 153         self.assertEqual(prox_test_data.rx_total, 7)
 154         self.assertEqual(prox_test_data.tx_total, 8)
 155         self.assertEqual(prox_test_data.requested_pps, 9)
 156
 157     def test_properties(self):
 158         prox_test_data = ProxTestDataTuple(1, 2, 3, 4, 5, 6, 7, 8, 9)
 159         self.assertEqual(prox_test_data.pkt_loss, 12.5)
 160         self.assertEqual(prox_test_data.tx_mpps, 1.6 / 1e6)
 161         self.assertEqual(prox_test_data.can_be_lost, 0)
 162         self.assertEqual(prox_test_data.drop_total, 1)
 163         self.assertFalse(prox_test_data.success)
 164
 165         prox_test_data = ProxTestDataTuple(10, 2, 3, 4, 5, 6, 997, 998, 9)
 166         self.assertTrue(prox_test_data.success)
 167
 168     def test_pkt_loss_zero_division(self):
 169         prox_test_data = ProxTestDataTuple(1, 2, 3, 4, 5, 6, 7, 0, 9)
 170         self.assertEqual(prox_test_data.pkt_loss, 100.0)
 171
 172     def test_get_samples(self):
 173         prox_test_data = ProxTestDataTuple(1, 2, 3, 4, 5, [6.1, 6.9, 6.4], 7, 8, 9)
 174
 175         expected = {
 176             "Throughput": 1.2 / 1e6,
 177             "DropPackets": 12.5,
 178             "CurrentDropPackets": 12.5,
 179             "RequestedTxThroughput": 9 / 1e6,
 180             "TxThroughput": 1.6 / 1e6,
 181             "RxThroughput": 1.2 / 1e6,
 182             "PktSize": 64,
 183             "PortSample": 1,
 184             "LatencyMin": 6.1,
 185             "LatencyMax": 6.9,
 186             "LatencyAvg": 6.4,
 187         }
 188         result = prox_test_data.get_samples(64, port_samples={"PortSample": 1})
 189         self.assertDictEqual(result, expected)
 190
 191         expected = {
 192             "Throughput": 1.2 / 1e6,
 193             "DropPackets": 0.123,
 194             "CurrentDropPackets": 0.123,
 195             "RequestedTxThroughput": 9 / 1e6,
 196             "TxThroughput": 1.6 / 1e6,
 197             "RxThroughput": 1.2 / 1e6,
 198             "PktSize": 64,
 199             "LatencyMin": 6.1,
 200             "LatencyMax": 6.9,
 201             "LatencyAvg": 6.4,
 202         }
 203         result = prox_test_data.get_samples(64, 0.123)
 204         self.assertDictEqual(result, expected)
 205
 206     @mock.patch('yardstick.LOG_RESULT', create=True)
 207     def test_log_data(self, mock_logger):
 208         my_mock_logger = mock.MagicMock()
 209         prox_test_data = ProxTestDataTuple(1, 2, 3, 4, 5, [6.1, 6.9, 6.4], 7, 8, 9)
 210         prox_test_data.log_data()
 211         self.assertEqual(my_mock_logger.debug.call_count, 0)
 212         self.assertEqual(mock_logger.debug.call_count, 0)
 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, 0)
 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, 1)
 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(
1543             vnfd_helper, sut, pkt_size, 25, None,
1544             constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1545
1546         self.assertEqual(data_helper.rx_total, 6)
1547         self.assertEqual(data_helper.tx_total, 7)
1548         self.assertEqual(data_helper.requested_pps, 6.25e6)
1549
1550     def test_samples(self):
1551         vnfd_helper = mock.MagicMock()
1552         vnfd_helper.port_pairs.all_ports = list(range(4))
1553         vnfd_helper.ports_iter.return_value = [('xe1', 3), ('xe2', 7)]
1554
1555         sut = mock.MagicMock()
1556         sut.port_stats.return_value = list(range(10))
1557
1558         data_helper = ProxDataHelper(vnfd_helper, sut, None, None, None, None)
1559
1560         expected = {
1561             'xe1': {
1562                 'in_packets': 6,
1563                 'out_packets': 7,
1564             },
1565             'xe2': {
1566                 'in_packets': 6,
1567                 'out_packets': 7,
1568             },
1569         }
1570         result = data_helper.samples
1571         self.assertDictEqual(result, expected)
1572
1573     def test___enter__(self):
1574         vnfd_helper = mock.MagicMock()
1575         vnfd_helper.port_pairs.all_ports = list(range(4))
1576         vnfd_helper.ports_iter.return_value = [('xe1', 3), ('xe2', 7)]
1577
1578         sut = mock.MagicMock()
1579         sut.port_stats.return_value = list(range(10))
1580
1581         data_helper = ProxDataHelper(vnfd_helper, sut, None, None,
1582             5.4, constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1583         data_helper._totals_and_pps = 12, 32, 4.5
1584         data_helper.tsc_hz = 9.8
1585         data_helper.measured_stats = {'delta': TotStatsTuple(6.1, 6.2, 6.3, 6.4)}
1586         data_helper.latency = 7
1587
1588         self.assertIsNone(data_helper.result_tuple)
1589         self.assertEqual(data_helper.line_speed, 10000000000)
1590
1591         expected = ProxTestDataTuple(5.4, 9.8, 6.1, 6.2, 6.3, 7, 12, 32, 4.5)
1592         with data_helper:
1593             pass
1594
1595         result = data_helper.result_tuple
1596         self.assertEqual(result, expected)
1597
1598         data_helper.make_tuple()
1599         self.assertIs(data_helper.result_tuple, result)
1600
1601     def test___enter___negative(self):
1602         vnfd_helper = mock.MagicMock()
1603
1604         data_helper = ProxDataHelper(vnfd_helper, None, None, None, None, None)
1605
1606         vnfd_helper.port_pairs.all_ports = []
1607         with self.assertRaises(AssertionError):
1608             with data_helper:
1609                 pass
1610
1611         vnfd_helper.port_pairs.all_ports = [0, 1, 2]
1612         with self.assertRaises(AssertionError):
1613             with data_helper:
1614                 pass
1615
1616     def test_measure_tot_stats(self):
1617         vnfd_helper = mock.MagicMock()
1618         vnfd_helper.port_pairs.all_ports = list(range(4))
1619
1620         start = (3, 4, 1, 2)
1621         end = (9, 7, 6, 8)
1622
1623         sut = ProxSocketHelper(mock.MagicMock())
1624         sut.get_all_tot_stats = mock.MagicMock(side_effect=[start, end])
1625
1626         data_helper = ProxDataHelper(vnfd_helper, sut, None, None, 5.4, None)
1627
1628         self.assertIsNone(data_helper.measured_stats)
1629
1630         expected = {
1631             'start_tot': start,
1632             'end_tot': end,
1633             'delta': TotStatsTuple(6, 3, 5, 6),
1634         }
1635         with data_helper.measure_tot_stats():
1636             pass
1637
1638         self.assertEqual(data_helper.measured_stats, expected)
1639
1640     def test_capture_tsc_hz(self):
1641         vnfd_helper = mock.MagicMock()
1642         vnfd_helper.port_pairs.all_ports = list(range(4))
1643
1644         sut = mock.MagicMock()
1645         sut.hz.return_value = '54.6'
1646
1647         data_helper = ProxDataHelper(vnfd_helper, sut, None, None, None, None)
1648
1649         self.assertIsNone(data_helper.tsc_hz)
1650
1651         expected = 54.6
1652         data_helper.capture_tsc_hz()
1653         self.assertEqual(data_helper.tsc_hz, expected)
1654
1655
1656 class TestProxProfileHelper(unittest.TestCase):
1657
1658     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.utils')
1659     def test_get_cls(self, mock_utils):
1660         mock_type1 = mock.MagicMock()
1661         mock_type1.__prox_profile_type__ = 'another_type'
1662         mock_type2 = mock.MagicMock()
1663         mock_type2.__prox_profile_type__ = 'my_type'
1664         mock_utils.itersubclasses.return_value = [mock_type1, mock_type2]
1665
1666         self.assertEqual(ProxProfileHelper.get_cls('my_type'), mock_type2)
1667
1668     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.utils')
1669     def test_get_cls_default(self, mock_utils):
1670         mock_utils.itersubclasses.return_value = []
1671         ProxProfileHelper.get_cls('my_type')
1672
1673     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.SocketTopology')
1674     def test_cpu_topology(self, mock_socket_topology):
1675         mock_socket_topology.parse_cpuinfo.return_value = 432
1676
1677         resource_helper = mock.MagicMock()
1678         resource_helper.setup_helper.ssh_helper.execute.return_value = 0, 'output', ''
1679
1680         helper = ProxProfileHelper(resource_helper)
1681         self.assertIsNone(helper._cpu_topology)
1682         result = helper.cpu_topology
1683         self.assertEqual(result, 432)
1684         self.assertIs(result, helper._cpu_topology)
1685         self.assertIs(result, helper.cpu_topology)
1686
1687     def test_test_cores(self):
1688         resource_helper = mock.MagicMock()
1689         resource_helper.setup_helper.prox_config_data = []
1690
1691         helper = ProxProfileHelper(resource_helper)
1692         helper._cpu_topology = []
1693
1694         expected = []
1695         result = helper.test_cores
1696         self.assertEqual(result, expected)
1697
1698         resource_helper.setup_helper.prox_config_data = [
1699             ('section1', []),
1700             ('section2', [
1701                 ('a', 'b'),
1702                 ('c', 'd'),
1703             ]),
1704             ('core 1s3', []),
1705             ('core 2s5', [
1706                 ('index', 8),
1707                 ('mode', ''),
1708             ]),
1709             ('core 3s1', [
1710                 ('index', 5),
1711                 ('mode', 'gen'),
1712             ]),
1713             ('core 4s9h', [
1714                 ('index', 7),
1715                 ('mode', 'gen'),
1716             ]),
1717         ]
1718
1719         helper = ProxProfileHelper(resource_helper)
1720         helper._cpu_topology = {
1721             1: {
1722                 3: {
1723                     'key1': (23, 32),
1724                     'key2': (12, 21),
1725                     'key3': (44, 33),
1726                 },
1727             },
1728             9: {
1729                 4: {
1730                     'key1': (44, 32),
1731                     'key2': (23, 21),
1732                     'key3': (12, 33),
1733                 },
1734             },
1735         }
1736
1737         self.assertIsNone(helper._test_cores)
1738         expected = [3, 4]
1739         result = helper.test_cores
1740         self.assertEqual(result, expected)
1741         self.assertIs(result, helper._test_cores)
1742         self.assertIs(result, helper.test_cores)
1743
1744     def test_latency_cores(self):
1745         resource_helper = mock.MagicMock()
1746         resource_helper.setup_helper.prox_config_data = []
1747
1748         helper = ProxProfileHelper(resource_helper)
1749         helper._cpu_topology = []
1750
1751         expected = []
1752         result = helper.latency_cores
1753         self.assertEqual(result, expected)
1754
1755         resource_helper.setup_helper.prox_config_data = [
1756             ('section1', []),
1757             ('section2', [
1758                 ('a', 'b'),
1759                 ('c', 'd'),
1760             ]),
1761             ('core 1s3', []),
1762             ('core 2s5', [
1763                 ('index', 8),
1764                 ('mode', ''),
1765             ]),
1766             ('core 3s1', [
1767                 ('index', 5),
1768                 ('mode', 'lat'),
1769             ]),
1770             ('core 4s9h', [
1771                 ('index', 7),
1772                 ('mode', 'lat'),
1773             ]),
1774         ]
1775
1776         helper = ProxProfileHelper(resource_helper)
1777         helper._cpu_topology = {
1778             1: {
1779                 3: {
1780                     'key1': (23, 32),
1781                     'key2': (12, 21),
1782                     'key3': (44, 33),
1783                 },
1784             },
1785             9: {
1786                 4: {
1787                     'key1': (44, 32),
1788                     'key2': (23, 21),
1789                     'key3': (12, 33),
1790                 },
1791             },
1792         }
1793
1794         self.assertIsNone(helper._latency_cores)
1795         expected = [3, 4]
1796         result = helper.latency_cores
1797         self.assertEqual(result, expected)
1798         self.assertIs(result, helper._latency_cores)
1799         self.assertIs(result, helper.latency_cores)
1800
1801     def test_all_rx_cores(self):
1802         helper = ProxBngProfileHelper(mock.MagicMock())
1803         helper._latency_cores = expected = [3, 4, 6]
1804         helper._test_cores = [5, 2, 1]
1805
1806         result = helper.all_rx_cores
1807         self.assertEqual(result, expected)
1808
1809     def test_get_cores(self):
1810         resource_helper = mock.MagicMock()
1811         resource_helper.setup_helper.prox_config_data = [
1812             ('section1', []),
1813             ('section2', [
1814                 ('a', 'b'),
1815                 ('c', 'd'),
1816             ]),
1817             ('core 1', []),
1818             ('core 2', [
1819                 ('index', 8),
1820                 ('mode', ''),
1821             ]),
1822             ('core 3', [
1823                 ('index', 5),
1824                 ('mode', 'gen'),
1825             ]),
1826             ('core 4', [
1827                 ('index', 7),
1828                 ('mode', 'gen'),
1829             ]),
1830         ]
1831
1832         helper = ProxProfileHelper(resource_helper)
1833         helper._cpu_topology = {
1834             0: {
1835                 1: {
1836                     5: (5, 1, 0)
1837                 },
1838                 2: {
1839                     6: (6, 2, 0)
1840                 },
1841                 3: {
1842                     7: (7, 3, 0)
1843                 },
1844                 4: {
1845                     8: (8, 3, 0)
1846                 },
1847             }
1848         }
1849
1850         expected = [3, 4]
1851         result = helper.get_cores(helper.PROX_CORE_GEN_MODE)
1852         self.assertEqual(result, expected)
1853
1854     def test_get_latency(self):
1855         resource_helper = mock.MagicMock()
1856         resource_helper.setup_helper.vnfd_helper.interfaces = []
1857
1858         helper = ProxProfileHelper(resource_helper)
1859         helper._latency_cores = []
1860
1861         expected = []
1862         result = helper.get_latency()
1863         self.assertEqual(result, expected)
1864
1865         helper._latency_cores = [1, 2]
1866         helper.client = mock.MagicMock()
1867
1868         expected = helper.sut.lat_stats()
1869         result = helper.get_latency()
1870         self.assertIs(result, expected)
1871
1872     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
1873     def test_traffic_context(self, *args):
1874         setup_helper = mock.MagicMock()
1875         setup_helper.vnfd_helper.interfaces = []
1876
1877         helper = ProxProfileHelper(setup_helper)
1878         helper._cpu_topology = {
1879             0: {
1880                 1: {
1881                     5: (5, 1, 0)
1882                 },
1883                 2: {
1884                     6: (6, 2, 0)
1885                 },
1886                 3: {
1887                     7: (7, 3, 0)
1888                 },
1889                 4: {
1890                     8: (8, 3, 0)
1891                 },
1892             }
1893         }
1894
1895         setup_helper.prox_config_data = [
1896             ('global', [
1897                 ('not_name', 'other data'),
1898                 ('name_not', 'more data'),
1899                 ('name', helper.__prox_profile_type__),
1900             ]),
1901             ('section1', []),
1902             ('section2', [
1903                 ('a', 'b'),
1904                 ('c', 'd'),
1905             ]),
1906             ('core 1', []),
1907             ('core 2', [
1908                 ('index', 8),
1909                 ('mode', ''),
1910             ]),
1911             ('core 3', [
1912                 ('index', 5),
1913                 ('mode', 'gen'),
1914                 ('name', 'tagged'),
1915             ]),
1916             ('core 4', [
1917                 ('index', 7),
1918                 ('mode', 'gen'),
1919                 ('name', 'udp'),
1920             ]),
1921         ]
1922
1923         client = mock.MagicMock()
1924         client.hz.return_value = 2
1925         client.port_stats.return_value = tuple(range(12))
1926
1927         helper.client = client
1928         helper.get_latency = mock.MagicMock(return_value=[3.3, 3.6, 3.8])
1929
1930         helper._test_cores = [3, 4]
1931
1932         with helper.traffic_context(64, 1):
1933             pass
1934
1935     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
1936     def test_run_test(self, _):
1937         resource_helper = mock.MagicMock()
1938         resource_helper.step_delta = 0.4
1939         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
1940         resource_helper.sut.port_stats.return_value = list(range(10))
1941
1942         helper = ProxProfileHelper(resource_helper)
1943
1944         helper.run_test(120, 5, 6.5,
1945                         constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1946
1947
1948 class TestProxMplsProfileHelper(unittest.TestCase):
1949
1950     def test_mpls_cores(self):
1951         resource_helper = mock.MagicMock()
1952         resource_helper.setup_helper.prox_config_data = [
1953             ('section1', []),
1954             ('section2', [
1955                 ('a', 'b'),
1956                 ('c', 'd'),
1957             ]),
1958             ('core 1', []),
1959             ('core 2', [
1960                 ('index', 8),
1961                 ('mode', ''),
1962             ]),
1963             ('core 3', [
1964                 ('index', 5),
1965                 ('mode', 'gen'),
1966                 ('name', 'tagged'),
1967             ]),
1968             ('core 4', [
1969                 ('index', 7),
1970                 ('mode', 'gen'),
1971                 ('name', 'udp'),
1972             ]),
1973         ]
1974
1975         helper = ProxMplsProfileHelper(resource_helper)
1976         helper._cpu_topology = {
1977             0: {
1978                 1: {
1979                     5: (5, 1, 0)
1980                 },
1981                 2: {
1982                     6: (6, 2, 0)
1983                 },
1984                 3: {
1985                     7: (7, 3, 0)
1986                 },
1987                 4: {
1988                     8: (8, 3, 0)
1989                 },
1990             }
1991         }
1992
1993         expected_tagged = [3]
1994         expected_plain = [4]
1995         self.assertIsNone(helper._cores_tuple)
1996         self.assertEqual(helper.tagged_cores, expected_tagged)
1997         self.assertEqual(helper.plain_cores, expected_plain)
1998         self.assertEqual(helper._cores_tuple, (expected_tagged, expected_plain))
1999
2000     def test_traffic_context(self):
2001         setup_helper = mock.MagicMock()
2002         helper = ProxMplsProfileHelper(setup_helper)
2003
2004         with helper.traffic_context(120, 5.4):
2005             pass
2006
2007
2008 class TestProxBngProfileHelper(unittest.TestCase):
2009
2010     def test_bng_cores(self):
2011         resource_helper = mock.MagicMock()
2012         resource_helper.setup_helper.prox_config_data = [
2013             ('section1', []),
2014             ('section2', [
2015                 ('a', 'b'),
2016                 ('c', 'd'),
2017             ]),
2018             ('core 1', []),
2019             ('core 2', [
2020                 ('index', 8),
2021                 ('mode', ''),
2022             ]),
2023             ('core 3', [
2024                 ('index', 5),
2025                 ('mode', 'gen'),
2026                 ('name', 'cpe'),
2027             ]),
2028             ('core 4', [
2029                 ('index', 7),
2030                 ('mode', 'gen'),
2031                 ('name', 'inet'),
2032             ]),
2033             ('core 6', [
2034                 ('index', 3),
2035                 ('mode', 'gen'),
2036                 ('name', 'arp_task'),
2037             ]),
2038             ('core 9', [
2039                 ('index', 2),
2040                 ('mode', 'gen'),
2041                 ('name', 'arp'),
2042             ]),
2043         ]
2044
2045         helper = ProxBngProfileHelper(resource_helper)
2046         helper._cpu_topology = {
2047             0: {
2048                 1: {
2049                     5: (5, 1, 0)
2050                 },
2051                 2: {
2052                     6: (6, 2, 0)
2053                 },
2054                 3: {
2055                     7: (7, 3, 0)
2056                 },
2057                 4: {
2058                     8: (8, 3, 0)
2059                 },
2060                 6: {
2061                     1: (4, 8, 0)
2062                 },
2063                 9: {
2064                     2: (3, 7, 0)
2065                 },
2066             }
2067         }
2068
2069         expected_cpe = [3]
2070         expected_inet = [4]
2071         expected_arp = [6, 9]
2072         expected_arp_task = [0, 6]
2073         expected_combined = (expected_cpe, expected_inet, expected_arp, expected_arp_task)
2074
2075         self.assertIsNone(helper._cores_tuple)
2076         self.assertEqual(helper.cpe_cores, expected_cpe)
2077         self.assertEqual(helper.inet_cores, expected_inet)
2078         self.assertEqual(helper.arp_cores, expected_arp)
2079         self.assertEqual(helper.arp_task_cores, expected_arp_task)
2080         self.assertEqual(helper._cores_tuple, expected_combined)
2081
2082     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
2083     def test_run_test(self, _):
2084         resource_helper = mock.MagicMock()
2085         resource_helper.step_delta = 0.4
2086         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2087         resource_helper.sut.port_stats.return_value = list(range(10))
2088
2089         helper = ProxBngProfileHelper(resource_helper)
2090
2091         helper.run_test(120, 5, 6.5,
2092                         constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2093
2094         # negative pkt_size is the only way to make ratio > 1
2095         helper.run_test(-1000, 5, 6.5,
2096                         constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2097
2098
2099 class TestProxVpeProfileHelper(unittest.TestCase):
2100
2101     def test_vpe_cores(self):
2102         resource_helper = mock.MagicMock()
2103         resource_helper.setup_helper.prox_config_data = [
2104             ('section1', []),
2105             ('section2', [
2106                 ('a', 'b'),
2107                 ('c', 'd'),
2108             ]),
2109             ('core 1', []),
2110             ('core 2', [
2111                 ('index', 8),
2112                 ('mode', ''),
2113             ]),
2114             ('core 3', [
2115                 ('index', 5),
2116                 ('mode', 'gen'),
2117                 ('name', 'cpe'),
2118             ]),
2119             ('core 4', [
2120                 ('index', 7),
2121                 ('mode', 'gen'),
2122                 ('name', 'inet'),
2123             ]),
2124         ]
2125
2126         helper = ProxVpeProfileHelper(resource_helper)
2127         helper._cpu_topology = {
2128             0: {
2129                 1: {
2130                     5: (5, 1, 0)
2131                 },
2132                 2: {
2133                     6: (6, 2, 0)
2134                 },
2135                 3: {
2136                     7: (7, 3, 0)
2137                 },
2138                 4: {
2139                     8: (8, 3, 0)
2140                 },
2141             }
2142         }
2143
2144         expected_cpe = [3]
2145         expected_inet = [4]
2146         expected_combined = (expected_cpe, expected_inet)
2147
2148         self.assertIsNone(helper._cores_tuple)
2149         self.assertEqual(helper.cpe_cores, expected_cpe)
2150         self.assertEqual(helper.inet_cores, expected_inet)
2151         self.assertEqual(helper._cores_tuple, expected_combined)
2152
2153     def test_vpe_ports(self):
2154         resource_helper = mock.MagicMock()
2155         resource_helper.setup_helper.prox_config_data = [
2156             ('section1', []),
2157             ('section2', [
2158                 ('a', 'b'),
2159                 ('c', 'd'),
2160             ]),
2161             ('port 3', [
2162                 ('index', '5'),
2163                 ('name', 'cpe'),
2164                 ('mac', 'hardware'),
2165             ]),
2166             ('port 4', [
2167                 ('index', '7'),
2168                 ('name', 'inet'),
2169                 ('mac', 'hardware'),
2170             ]),
2171         ]
2172
2173         helper = ProxVpeProfileHelper(resource_helper)
2174         helper._port_list = {
2175             0: {
2176                 1: {
2177                     5: 'cpe'
2178                 },
2179                 2: {
2180                     6: 'inet'
2181                 },
2182                 3: {
2183                     7: 'cpe'
2184                 },
2185                 4: {
2186                     8: 'inet'
2187                 },
2188             }
2189         }
2190
2191         expected_cpe = [3]
2192         expected_inet = [4]
2193         expected_combined = (expected_cpe, expected_inet)
2194
2195         self.assertIsNone(helper._ports_tuple)
2196         self.assertEqual(helper.cpe_ports, expected_cpe)
2197         self.assertEqual(helper.inet_ports, expected_inet)
2198         self.assertEqual(helper._ports_tuple, expected_combined)
2199
2200     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
2201     def test_run_test(self, _):
2202         resource_helper = mock.MagicMock()
2203         resource_helper.step_delta = 0.4
2204         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2205         resource_helper.sut.port_stats.return_value = list(range(10))
2206
2207         helper = ProxVpeProfileHelper(resource_helper)
2208
2209         helper.run_test(120, 5, 6.5)
2210         helper.run_test(-1000, 5, 6.5)  # negative pkt_size is the only way to make ratio > 1
2211
2212
2213 class TestProxlwAFTRProfileHelper(unittest.TestCase):
2214
2215     def test_lwaftr_cores(self):
2216         resource_helper = mock.MagicMock()
2217         resource_helper.setup_helper.prox_config_data = [
2218             ('section1', []),
2219             ('section2', [
2220                 ('a', 'b'),
2221                 ('c', 'd'),
2222             ]),
2223             ('core 1', []),
2224             ('core 2', [
2225                 ('index', 8),
2226                 ('mode', ''),
2227             ]),
2228             ('core 3', [
2229                 ('index', 5),
2230                 ('mode', 'gen'),
2231                 ('name', 'tun'),
2232             ]),
2233             ('core 4', [
2234                 ('index', 7),
2235                 ('mode', 'gen'),
2236                 ('name', 'inet'),
2237             ]),
2238         ]
2239
2240         helper = ProxlwAFTRProfileHelper(resource_helper)
2241         helper._cpu_topology = {
2242             0: {
2243                 1: {
2244                     5: (5, 1, 0)
2245                 },
2246                 2: {
2247                     6: (6, 2, 0)
2248                 },
2249                 3: {
2250                     7: (7, 3, 0)
2251                 },
2252                 4: {
2253                     8: (8, 3, 0)
2254                 },
2255             }
2256         }
2257
2258         expected_tun = [3]
2259         expected_inet = [4]
2260         expected_combined = (expected_tun, expected_inet)
2261
2262         self.assertIsNone(helper._cores_tuple)
2263         self.assertEqual(helper.tun_cores, expected_tun)
2264         self.assertEqual(helper.inet_cores, expected_inet)
2265         self.assertEqual(helper._cores_tuple, expected_combined)
2266
2267     def test_tun_ports(self):
2268         resource_helper = mock.MagicMock()
2269         resource_helper.setup_helper.prox_config_data = [
2270             ('section1', []),
2271             ('section2', [
2272                 ('a', 'b'),
2273                 ('c', 'd'),
2274             ]),
2275             ('port 3', [
2276                 ('index', '5'),
2277                 ('name', 'lwB4'),
2278                 ('mac', 'hardware'),
2279             ]),
2280             ('port 4', [
2281                 ('index', '7'),
2282                 ('name', 'inet'),
2283                 ('mac', 'hardware'),
2284             ]),
2285         ]
2286
2287         helper = ProxlwAFTRProfileHelper(resource_helper)
2288         helper._port_list = {
2289             0: {
2290                 1: {
2291                     5: 'lwB4'
2292                 },
2293                 2: {
2294                     6: 'inet'
2295                 },
2296                 3: {
2297                     7: 'lwB4'
2298                 },
2299                 4: {
2300                     8: 'inet'
2301                 },
2302             }
2303         }
2304
2305         expected_tun = [3]
2306         expected_inet = [4]
2307         expected_combined = (expected_tun, expected_inet)
2308
2309         self.assertIsNone(helper._ports_tuple)
2310         self.assertEqual(helper.tun_ports, expected_tun)
2311         self.assertEqual(helper.inet_ports, expected_inet)
2312         self.assertEqual(helper._ports_tuple, expected_combined)
2313
2314     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
2315     def test_run_test(self, _):
2316         resource_helper = mock.MagicMock()
2317         resource_helper.step_delta = 0.4
2318         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2319         resource_helper.sut.port_stats.return_value = list(range(10))
2320
2321         helper = ProxlwAFTRProfileHelper(resource_helper)
2322
2323         helper.run_test(120, 5, 6.5)
2324         helper.run_test(-1000, 5, 6.5)  # negative pkt_size is the only way to make ratio > 1