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

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