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()
1531         traffic_profile.done.is_set.return_value = True
1532         helper.run_traffic(traffic_profile)
1533         self.assertEqual(helper._terminated.value, 1)
1534
1535     def test__run_traffic_once(self):
1536         setup_helper = mock.MagicMock()
1537         helper = prox_helpers.ProxResourceHelper(setup_helper)
1538         traffic_profile = mock.MagicMock()
1539         traffic_profile.done.is_set.return_value = True
1540         helper._run_traffic_once(traffic_profile)
1541         self.assertEqual(helper._terminated.value, 1)
1542
1543     def test_start_collect(self):
1544         setup_helper = mock.MagicMock()
1545         helper = prox_helpers.ProxResourceHelper(setup_helper)
1546         helper.resource = resource = mock.MagicMock()
1547         self.assertIsNone(helper.start_collect())
1548         resource.start.assert_called_once()
1549
1550     def test_terminate(self):
1551         setup_helper = mock.MagicMock()
1552         helper = prox_helpers.ProxResourceHelper(setup_helper)
1553         with self.assertRaises(NotImplementedError):
1554             helper.terminate()
1555
1556     def test_up_post(self):
1557         setup_helper = mock.MagicMock()
1558         helper = prox_helpers.ProxResourceHelper(setup_helper)
1559         helper.client = expected = mock.MagicMock()
1560         result = helper.up_post()
1561         self.assertEqual(result, expected)
1562
1563     def test_execute(self):
1564         setup_helper = mock.MagicMock()
1565         helper = prox_helpers.ProxResourceHelper(setup_helper)
1566         helper.client = mock.MagicMock()
1567
1568         expected = helper.client.my_command()
1569         result = helper.execute('my_command')
1570         self.assertEqual(result, expected)
1571
1572         # TODO(elfoley): Make this a separate test: test_execute_no_client
1573         helper.client = object()
1574
1575         result = helper.execute('my_command')
1576         self.assertIsNone(result)
1577
1578
1579 class TestProxDataHelper(unittest.TestCase):
1580
1581     def test_totals_and_pps(self):
1582         pkt_size = 180
1583         vnfd_helper = mock.MagicMock()
1584         vnfd_helper.port_pairs.all_ports = list(range(4))
1585
1586         sut = mock.MagicMock()
1587         sut.multi_port_stats.return_value = [[0, 1, 2, 3, 4, 5], [1, 1, 2, 3, 4, 5],
1588                                              [2, 1, 2, 3, 4, 5], [3, 1, 2, 3, 4, 5]]
1589
1590         data_helper = prox_helpers.ProxDataHelper(
1591             vnfd_helper, sut, pkt_size, 25, None,
1592             constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1593
1594         self.assertEqual(data_helper.rx_total, 4)
1595         self.assertEqual(data_helper.tx_total, 8)
1596         self.assertEqual(data_helper.requested_pps, 6.25e6)
1597
1598     def test_samples(self):
1599         vnfd_helper = mock.MagicMock()
1600         vnfd_helper.ports_iter.return_value = [('xe0', 0), ('xe1', 1)]
1601
1602         sut = mock.MagicMock()
1603         sut.multi_port_stats.return_value = [[0, 1, 2, 3, 4, 5], [1, 11, 12, 3, 4, 5]]
1604
1605         data_helper = prox_helpers.ProxDataHelper(
1606             vnfd_helper, sut, None, None, None, None)
1607
1608         expected = {
1609             'xe0': {
1610                 'in_packets': 1,
1611                 'out_packets': 2,
1612             },
1613             'xe1': {
1614                 'in_packets': 11,
1615                 'out_packets': 12,
1616             },
1617         }
1618         result = data_helper.samples
1619         self.assertDictEqual(result, expected)
1620
1621     def test___enter__(self):
1622         vnfd_helper = mock.MagicMock()
1623         vnfd_helper.port_pairs.all_ports = list(range(4))
1624         vnfd_helper.ports_iter.return_value = [('xe1', 3), ('xe2', 7)]
1625
1626         sut = mock.MagicMock()
1627         sut.port_stats.return_value = list(range(10))
1628
1629         data_helper = prox_helpers.ProxDataHelper(vnfd_helper, sut, None, None,
1630             5.4, constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1631         data_helper._totals_and_pps = 12, 32, 4.5
1632         data_helper.tsc_hz = 9.8
1633         data_helper.measured_stats = {
1634             'delta': prox_helpers.TotStatsTuple(6.1, 6.2, 6.3, 6.4)}
1635         data_helper.latency = 7
1636
1637         self.assertIsNone(data_helper.result_tuple)
1638         self.assertEqual(data_helper.line_speed, 10000000000)
1639
1640         expected = prox_helpers.ProxTestDataTuple(
1641             5.4, 9.8, 6.1, 6.2, 6.3, 7, 12, 32, 4.5)
1642         with data_helper:
1643             pass
1644
1645         result = data_helper.result_tuple
1646         self.assertEqual(result, expected)
1647
1648         data_helper.make_tuple()
1649         self.assertIs(data_helper.result_tuple, result)
1650
1651     def test___enter___negative(self):
1652         vnfd_helper = mock.MagicMock()
1653
1654         data_helper = prox_helpers.ProxDataHelper(
1655             vnfd_helper, None, None, None, None, None)
1656
1657         vnfd_helper.port_pairs.all_ports = []
1658         with self.assertRaises(AssertionError):
1659             with data_helper:
1660                 pass
1661
1662         vnfd_helper.port_pairs.all_ports = [0, 1, 2]
1663         with self.assertRaises(AssertionError):
1664             with data_helper:
1665                 pass
1666
1667     def test_measure_tot_stats(self):
1668         vnfd_helper = mock.MagicMock()
1669         vnfd_helper.port_pairs.all_ports = list(range(4))
1670
1671         start = (3, 4, 1, 2)
1672         end = (9, 7, 6, 8)
1673
1674         sut = prox_helpers.ProxSocketHelper(mock.MagicMock())
1675         sut.get_all_tot_stats = mock.MagicMock(side_effect=[start, end])
1676
1677         data_helper = prox_helpers.ProxDataHelper(
1678             vnfd_helper, sut, None, None, 5.4, None)
1679
1680         self.assertIsNone(data_helper.measured_stats)
1681
1682         expected = {
1683             'start_tot': start,
1684             'end_tot': end,
1685             'delta': prox_helpers.TotStatsTuple(6, 3, 5, 6),
1686         }
1687         with data_helper.measure_tot_stats():
1688             pass
1689
1690         self.assertEqual(data_helper.measured_stats, expected)
1691
1692     def test_capture_tsc_hz(self):
1693         vnfd_helper = mock.MagicMock()
1694         vnfd_helper.port_pairs.all_ports = list(range(4))
1695
1696         sut = mock.MagicMock()
1697         sut.hz.return_value = '54.6'
1698
1699         data_helper = prox_helpers.ProxDataHelper(
1700             vnfd_helper, sut, None, None, None, None)
1701
1702         self.assertIsNone(data_helper.tsc_hz)
1703
1704         expected = 54.6
1705         data_helper.capture_tsc_hz()
1706         self.assertEqual(data_helper.tsc_hz, expected)
1707
1708
1709 class TestProxProfileHelper(unittest.TestCase):
1710
1711     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.utils')
1712     def test_get_cls(self, mock_utils):
1713         mock_type1 = mock.MagicMock()
1714         mock_type1.__prox_profile_type__ = 'another_type'
1715         mock_type2 = mock.MagicMock()
1716         mock_type2.__prox_profile_type__ = 'my_type'
1717         mock_utils.itersubclasses.return_value = [mock_type1, mock_type2]
1718
1719         self.assertEqual(prox_helpers.ProxProfileHelper.get_cls('my_type'),
1720                          mock_type2)
1721
1722     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.utils')
1723     def test_get_cls_default(self, mock_utils):
1724         mock_utils.itersubclasses.return_value = []
1725         prox_helpers.ProxProfileHelper.get_cls('my_type')
1726
1727     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.SocketTopology')
1728     def test_cpu_topology(self, mock_socket_topology):
1729         mock_socket_topology.parse_cpuinfo.return_value = 432
1730
1731         resource_helper = mock.MagicMock()
1732         resource_helper.setup_helper.ssh_helper.execute.return_value = 0, 'output', ''
1733
1734         helper = prox_helpers.ProxProfileHelper(resource_helper)
1735         self.assertIsNone(helper._cpu_topology)
1736         result = helper.cpu_topology
1737         self.assertEqual(result, 432)
1738         self.assertIs(result, helper._cpu_topology)
1739         self.assertIs(result, helper.cpu_topology)
1740
1741     # TODO(elfoley): Split this test; there are two sets of inputs/outputs
1742     def test_test_cores(self):
1743         resource_helper = mock.MagicMock()
1744         resource_helper.setup_helper.prox_config_data = []
1745
1746         helper = prox_helpers.ProxProfileHelper(resource_helper)
1747         helper._cpu_topology = []
1748
1749         expected = []
1750         result = helper.test_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', 'gen'),
1767             ]),
1768             ('core 4s9h', [
1769                 ('index', 7),
1770                 ('mode', 'gen'),
1771             ]),
1772         ]
1773
1774         helper = prox_helpers.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._test_cores)
1793         expected = [3, 4]
1794         result = helper.test_cores
1795         self.assertEqual(result, expected)
1796         self.assertIs(result, helper._test_cores)
1797         self.assertIs(result, helper.test_cores)
1798
1799     # TODO(elfoley): Split this test; there are two sets of inputs/outputs
1800     def test_latency_cores(self):
1801         resource_helper = mock.MagicMock()
1802         resource_helper.setup_helper.prox_config_data = []
1803
1804         helper = prox_helpers.ProxProfileHelper(resource_helper)
1805         helper._cpu_topology = []
1806
1807         expected = []
1808         result = helper.latency_cores
1809         self.assertEqual(result, expected)
1810
1811         resource_helper.setup_helper.prox_config_data = [
1812             ('section1', []),
1813             ('section2', [
1814                 ('a', 'b'),
1815                 ('c', 'd'),
1816             ]),
1817             ('core 1s3', []),
1818             ('core 2s5', [
1819                 ('index', 8),
1820                 ('mode', ''),
1821             ]),
1822             ('core 3s1', [
1823                 ('index', 5),
1824                 ('mode', 'lat'),
1825             ]),
1826             ('core 4s9h', [
1827                 ('index', 7),
1828                 ('mode', 'lat'),
1829             ]),
1830         ]
1831
1832         helper = prox_helpers.ProxProfileHelper(resource_helper)
1833         helper._cpu_topology = {
1834             1: {
1835                 3: {
1836                     'key1': (23, 32),
1837                     'key2': (12, 21),
1838                     'key3': (44, 33),
1839                 },
1840             },
1841             9: {
1842                 4: {
1843                     'key1': (44, 32),
1844                     'key2': (23, 21),
1845                     'key3': (12, 33),
1846                 },
1847             },
1848         }
1849
1850         self.assertIsNone(helper._latency_cores)
1851         expected = [3, 4]
1852         result = helper.latency_cores
1853         self.assertEqual(result, expected)
1854         self.assertIs(result, helper._latency_cores)
1855         self.assertIs(result, helper.latency_cores)
1856
1857     def test_all_rx_cores(self):
1858         helper = prox_helpers.ProxBngProfileHelper(mock.MagicMock())
1859         helper._latency_cores = expected = [3, 4, 6]
1860         helper._test_cores = [5, 2, 1]
1861
1862         result = helper.all_rx_cores
1863         self.assertEqual(result, expected)
1864
1865     def test_get_cores(self):
1866         resource_helper = mock.MagicMock()
1867         resource_helper.setup_helper.prox_config_data = [
1868             ('section1', []),
1869             ('section2', [
1870                 ('a', 'b'),
1871                 ('c', 'd'),
1872             ]),
1873             ('core 1', []),
1874             ('core 2', [
1875                 ('index', 8),
1876                 ('mode', ''),
1877             ]),
1878             ('core 3', [
1879                 ('index', 5),
1880                 ('mode', 'gen'),
1881             ]),
1882             ('core 4', [
1883                 ('index', 7),
1884                 ('mode', 'gen'),
1885             ]),
1886         ]
1887
1888         helper = prox_helpers.ProxProfileHelper(resource_helper)
1889         helper._cpu_topology = {
1890             0: {
1891                 1: {
1892                     5: (5, 1, 0)
1893                 },
1894                 2: {
1895                     6: (6, 2, 0)
1896                 },
1897                 3: {
1898                     7: (7, 3, 0)
1899                 },
1900                 4: {
1901                     8: (8, 3, 0)
1902                 },
1903             }
1904         }
1905
1906         expected = [3, 4]
1907         result = helper.get_cores(helper.PROX_CORE_GEN_MODE)
1908         self.assertEqual(result, expected)
1909
1910     def test_get_latency(self):
1911         resource_helper = mock.MagicMock()
1912         resource_helper.setup_helper.vnfd_helper.interfaces = []
1913
1914         helper = prox_helpers.ProxProfileHelper(resource_helper)
1915         helper._latency_cores = []
1916
1917         expected = []
1918         result = helper.get_latency()
1919         self.assertEqual(result, expected)
1920
1921         helper._latency_cores = [1, 2]
1922         helper.client = mock.MagicMock()
1923
1924         expected = helper.sut.lat_stats()
1925         result = helper.get_latency()
1926         self.assertIs(result, expected)
1927
1928     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
1929     def test_traffic_context(self, *args):
1930         setup_helper = mock.MagicMock()
1931         setup_helper.vnfd_helper.interfaces = []
1932
1933         helper = prox_helpers.ProxProfileHelper(setup_helper)
1934         helper._cpu_topology = {
1935             0: {
1936                 1: {
1937                     5: (5, 1, 0)
1938                 },
1939                 2: {
1940                     6: (6, 2, 0)
1941                 },
1942                 3: {
1943                     7: (7, 3, 0)
1944                 },
1945                 4: {
1946                     8: (8, 3, 0)
1947                 },
1948             }
1949         }
1950
1951         setup_helper.prox_config_data = [
1952             ('global', [
1953                 ('not_name', 'other data'),
1954                 ('name_not', 'more data'),
1955                 ('name', helper.__prox_profile_type__),
1956             ]),
1957             ('section1', []),
1958             ('section2', [
1959                 ('a', 'b'),
1960                 ('c', 'd'),
1961             ]),
1962             ('core 1', []),
1963             ('core 2', [
1964                 ('index', 8),
1965                 ('mode', ''),
1966             ]),
1967             ('core 3', [
1968                 ('index', 5),
1969                 ('mode', 'gen'),
1970                 ('name', 'tagged'),
1971             ]),
1972             ('core 4', [
1973                 ('index', 7),
1974                 ('mode', 'gen'),
1975                 ('name', 'udp'),
1976             ]),
1977         ]
1978
1979         client = mock.MagicMock()
1980         client.hz.return_value = 2
1981         client.port_stats.return_value = tuple(range(12))
1982
1983         helper.client = client
1984         helper.get_latency = mock.MagicMock(return_value=[3.3, 3.6, 3.8])
1985
1986         helper._test_cores = [3, 4]
1987
1988         with helper.traffic_context(64, 1):
1989             pass
1990
1991     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
1992     def test_run_test(self, _):
1993         resource_helper = mock.MagicMock()
1994         resource_helper.step_delta = 0.4
1995         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
1996         resource_helper.sut.port_stats.return_value = list(range(10))
1997
1998         helper = prox_helpers.ProxProfileHelper(resource_helper)
1999
2000         helper.run_test(120, 5, 6.5,
2001                         constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2002
2003
2004 class TestProxMplsProfileHelper(unittest.TestCase):
2005
2006     def test_mpls_cores(self):
2007         resource_helper = mock.MagicMock()
2008         resource_helper.setup_helper.prox_config_data = [
2009             ('section1', []),
2010             ('section2', [
2011                 ('a', 'b'),
2012                 ('c', 'd'),
2013             ]),
2014             ('core 1', []),
2015             ('core 2', [
2016                 ('index', 8),
2017                 ('mode', ''),
2018             ]),
2019             ('core 3', [
2020                 ('index', 5),
2021                 ('mode', 'gen'),
2022                 ('name', 'tagged'),
2023             ]),
2024             ('core 4', [
2025                 ('index', 7),
2026                 ('mode', 'gen'),
2027                 ('name', 'udp'),
2028             ]),
2029         ]
2030
2031         helper = prox_helpers.ProxMplsProfileHelper(resource_helper)
2032         helper._cpu_topology = {
2033             0: {
2034                 1: {
2035                     5: (5, 1, 0)
2036                 },
2037                 2: {
2038                     6: (6, 2, 0)
2039                 },
2040                 3: {
2041                     7: (7, 3, 0)
2042                 },
2043                 4: {
2044                     8: (8, 3, 0)
2045                 },
2046             }
2047         }
2048
2049         expected_tagged = [3]
2050         expected_plain = [4]
2051         self.assertIsNone(helper._cores_tuple)
2052         self.assertEqual(helper.tagged_cores, expected_tagged)
2053         self.assertEqual(helper.plain_cores, expected_plain)
2054         self.assertEqual(helper._cores_tuple, (expected_tagged, expected_plain))
2055
2056     def test_traffic_context(self):
2057         setup_helper = mock.MagicMock()
2058         helper = prox_helpers.ProxMplsProfileHelper(setup_helper)
2059
2060         with helper.traffic_context(120, 5.4):
2061             pass
2062
2063
2064 class TestProxBngProfileHelper(unittest.TestCase):
2065
2066     def test_bng_cores(self):
2067         resource_helper = mock.MagicMock()
2068         resource_helper.setup_helper.prox_config_data = [
2069             ('section1', []),
2070             ('section2', [
2071                 ('a', 'b'),
2072                 ('c', 'd'),
2073             ]),
2074             ('core 1', []),
2075             ('core 2', [
2076                 ('index', 8),
2077                 ('mode', ''),
2078             ]),
2079             ('core 3', [
2080                 ('index', 5),
2081                 ('mode', 'gen'),
2082                 ('name', 'cpe'),
2083             ]),
2084             ('core 4', [
2085                 ('index', 7),
2086                 ('mode', 'gen'),
2087                 ('name', 'inet'),
2088             ]),
2089             ('core 6', [
2090                 ('index', 3),
2091                 ('mode', 'gen'),
2092                 ('name', 'arp_task'),
2093             ]),
2094             ('core 9', [
2095                 ('index', 2),
2096                 ('mode', 'gen'),
2097                 ('name', 'arp'),
2098             ]),
2099         ]
2100
2101         helper = prox_helpers.ProxBngProfileHelper(resource_helper)
2102         helper._cpu_topology = {
2103             0: {
2104                 1: {
2105                     5: (5, 1, 0)
2106                 },
2107                 2: {
2108                     6: (6, 2, 0)
2109                 },
2110                 3: {
2111                     7: (7, 3, 0)
2112                 },
2113                 4: {
2114                     8: (8, 3, 0)
2115                 },
2116                 6: {
2117                     1: (4, 8, 0)
2118                 },
2119                 9: {
2120                     2: (3, 7, 0)
2121                 },
2122             }
2123         }
2124
2125         expected_cpe = [3]
2126         expected_inet = [4]
2127         expected_arp = [6, 9]
2128         expected_arp_task = [0, 6]
2129         expected_combined = (expected_cpe, expected_inet, expected_arp, expected_arp_task)
2130
2131         self.assertIsNone(helper._cores_tuple)
2132         self.assertEqual(helper.cpe_cores, expected_cpe)
2133         self.assertEqual(helper.inet_cores, expected_inet)
2134         self.assertEqual(helper.arp_cores, expected_arp)
2135         self.assertEqual(helper.arp_task_cores, expected_arp_task)
2136         self.assertEqual(helper._cores_tuple, expected_combined)
2137
2138     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
2139     def test_run_test(self, _):
2140         resource_helper = mock.MagicMock()
2141         resource_helper.step_delta = 0.4
2142         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2143         resource_helper.sut.port_stats.return_value = list(range(10))
2144
2145         helper = prox_helpers.ProxBngProfileHelper(resource_helper)
2146
2147         helper.run_test(120, 5, 6.5,
2148                         constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2149
2150         # negative pkt_size is the only way to make ratio > 1
2151         helper.run_test(-1000, 5, 6.5,
2152                         constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2153
2154
2155 class TestProxVpeProfileHelper(unittest.TestCase):
2156
2157     def test_vpe_cores(self):
2158         resource_helper = mock.MagicMock()
2159         resource_helper.setup_helper.prox_config_data = [
2160             ('section1', []),
2161             ('section2', [
2162                 ('a', 'b'),
2163                 ('c', 'd'),
2164             ]),
2165             ('core 1', []),
2166             ('core 2', [
2167                 ('index', 8),
2168                 ('mode', ''),
2169             ]),
2170             ('core 3', [
2171                 ('index', 5),
2172                 ('mode', 'gen'),
2173                 ('name', 'cpe'),
2174             ]),
2175             ('core 4', [
2176                 ('index', 7),
2177                 ('mode', 'gen'),
2178                 ('name', 'inet'),
2179             ]),
2180         ]
2181
2182         helper = prox_helpers.ProxVpeProfileHelper(resource_helper)
2183         helper._cpu_topology = {
2184             0: {
2185                 1: {
2186                     5: (5, 1, 0)
2187                 },
2188                 2: {
2189                     6: (6, 2, 0)
2190                 },
2191                 3: {
2192                     7: (7, 3, 0)
2193                 },
2194                 4: {
2195                     8: (8, 3, 0)
2196                 },
2197             }
2198         }
2199
2200         expected_cpe = [3]
2201         expected_inet = [4]
2202         expected_combined = (expected_cpe, expected_inet)
2203
2204         self.assertIsNone(helper._cores_tuple)
2205         self.assertEqual(helper.cpe_cores, expected_cpe)
2206         self.assertEqual(helper.inet_cores, expected_inet)
2207         self.assertEqual(helper._cores_tuple, expected_combined)
2208
2209     def test_vpe_ports(self):
2210         resource_helper = mock.MagicMock()
2211         resource_helper.setup_helper.prox_config_data = [
2212             ('section1', []),
2213             ('section2', [
2214                 ('a', 'b'),
2215                 ('c', 'd'),
2216             ]),
2217             ('port 3', [
2218                 ('index', '5'),
2219                 ('name', 'cpe'),
2220                 ('mac', 'hardware'),
2221             ]),
2222             ('port 4', [
2223                 ('index', '7'),
2224                 ('name', 'inet'),
2225                 ('mac', 'hardware'),
2226             ]),
2227         ]
2228
2229         helper = prox_helpers.ProxVpeProfileHelper(resource_helper)
2230         helper._port_list = {
2231             0: {
2232                 1: {
2233                     5: 'cpe'
2234                 },
2235                 2: {
2236                     6: 'inet'
2237                 },
2238                 3: {
2239                     7: 'cpe'
2240                 },
2241                 4: {
2242                     8: 'inet'
2243                 },
2244             }
2245         }
2246
2247         expected_cpe = [3]
2248         expected_inet = [4]
2249         expected_combined = (expected_cpe, expected_inet)
2250
2251         self.assertIsNone(helper._ports_tuple)
2252         self.assertEqual(helper.cpe_ports, expected_cpe)
2253         self.assertEqual(helper.inet_ports, expected_inet)
2254         self.assertEqual(helper._ports_tuple, expected_combined)
2255
2256     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
2257     def test_run_test(self, _):
2258         resource_helper = mock.MagicMock()
2259         resource_helper.step_delta = 0.4
2260         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2261         resource_helper.sut.port_stats.return_value = list(range(10))
2262
2263         helper = prox_helpers.ProxVpeProfileHelper(resource_helper)
2264
2265         helper.run_test(120, 5, 6.5)
2266         helper.run_test(-1000, 5, 6.5)  # negative pkt_size is the only way to make ratio > 1
2267
2268
2269 class TestProxlwAFTRProfileHelper(unittest.TestCase):
2270
2271     def test_lwaftr_cores(self):
2272         resource_helper = mock.MagicMock()
2273         resource_helper.setup_helper.prox_config_data = [
2274             ('section1', []),
2275             ('section2', [
2276                 ('a', 'b'),
2277                 ('c', 'd'),
2278             ]),
2279             ('core 1', []),
2280             ('core 2', [
2281                 ('index', 8),
2282                 ('mode', ''),
2283             ]),
2284             ('core 3', [
2285                 ('index', 5),
2286                 ('mode', 'gen'),
2287                 ('name', 'tun'),
2288             ]),
2289             ('core 4', [
2290                 ('index', 7),
2291                 ('mode', 'gen'),
2292                 ('name', 'inet'),
2293             ]),
2294         ]
2295
2296         helper = prox_helpers.ProxlwAFTRProfileHelper(resource_helper)
2297         helper._cpu_topology = {
2298             0: {
2299                 1: {
2300                     5: (5, 1, 0)
2301                 },
2302                 2: {
2303                     6: (6, 2, 0)
2304                 },
2305                 3: {
2306                     7: (7, 3, 0)
2307                 },
2308                 4: {
2309                     8: (8, 3, 0)
2310                 },
2311             }
2312         }
2313
2314         expected_tun = [3]
2315         expected_inet = [4]
2316         expected_combined = (expected_tun, expected_inet)
2317
2318         self.assertIsNone(helper._cores_tuple)
2319         self.assertEqual(helper.tun_cores, expected_tun)
2320         self.assertEqual(helper.inet_cores, expected_inet)
2321         self.assertEqual(helper._cores_tuple, expected_combined)
2322
2323     def test_tun_ports(self):
2324         resource_helper = mock.MagicMock()
2325         resource_helper.setup_helper.prox_config_data = [
2326             ('section1', []),
2327             ('section2', [
2328                 ('a', 'b'),
2329                 ('c', 'd'),
2330             ]),
2331             ('port 3', [
2332                 ('index', '5'),
2333                 ('name', 'lwB4'),
2334                 ('mac', 'hardware'),
2335             ]),
2336             ('port 4', [
2337                 ('index', '7'),
2338                 ('name', 'inet'),
2339                 ('mac', 'hardware'),
2340             ]),
2341         ]
2342
2343         helper = prox_helpers.ProxlwAFTRProfileHelper(resource_helper)
2344         helper._port_list = {
2345             0: {
2346                 1: {
2347                     5: 'lwB4'
2348                 },
2349                 2: {
2350                     6: 'inet'
2351                 },
2352                 3: {
2353                     7: 'lwB4'
2354                 },
2355                 4: {
2356                     8: 'inet'
2357                 },
2358             }
2359         }
2360
2361         expected_tun = [3]
2362         expected_inet = [4]
2363         expected_combined = (expected_tun, expected_inet)
2364
2365         self.assertIsNone(helper._ports_tuple)
2366         self.assertEqual(helper.tun_ports, expected_tun)
2367         self.assertEqual(helper.inet_ports, expected_inet)
2368         self.assertEqual(helper._ports_tuple, expected_combined)
2369
2370     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
2371     def test_run_test(self, _):
2372         resource_helper = mock.MagicMock()
2373         resource_helper.step_delta = 0.4
2374         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2375         resource_helper.sut.port_stats.return_value = list(range(10))
2376
2377         helper = prox_helpers.ProxlwAFTRProfileHelper(resource_helper)
2378
2379         helper.run_test(120, 5, 6.5)
2380         helper.run_test(-1000, 5, 6.5)  # negative pkt_size is the only way to make ratio > 1