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