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

   1 # Copyright (c) 2016-2018 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'], ['']],
 324                                                repeat([1], 3))
 325         mock_recv.decode.return_value = PACKET_DUMP_1
 326         ret = prox.get_data()
 327         self.assertEqual(mock_select.select.call_count, 2)
 328         self.assertEqual(ret, 'pktdump,3,11')
 329         self.assertEqual(len(prox._pkt_dumps), 1)
 330
 331         mock_select.select.reset_mock()
 332         mock_select.select.side_effect = chain([[object()], [None]],
 333                                                repeat([1], 3))
 334         mock_recv.decode.return_value = PACKET_DUMP_2
 335         ret = prox.get_data()
 336         self.assertEqual(mock_select.select.call_count, 1)
 337         self.assertEqual(ret, 'jumped over')
 338         self.assertEqual(len(prox._pkt_dumps), 3)
 339
 340     @mock.patch.object(prox_helpers, 'select')
 341     def test_get_string(self, mock_select):
 342         mock_select.select.side_effect = [[1], [0]]
 343         mock_socket = mock.MagicMock()
 344         mock_recv = mock_socket.recv()
 345         mock_recv.decode.return_value = ""
 346         prox = prox_helpers.ProxSocketHelper(mock_socket)
 347         status, ret = prox.get_string()
 348         self.assertEqual(ret, "")
 349         self.assertTrue(status)
 350         self.assertEqual(len(prox._pkt_dumps), 0)
 351
 352     @mock.patch.object(prox_helpers, 'select')
 353     def test_get_string2(self, mock_select):
 354         mock_select.select.side_effect = chain([['a'], ['']],
 355                                                repeat([1], 3))
 356         mock_socket = mock.MagicMock()
 357         mock_recv = mock_socket.recv()
 358         mock_recv.decode.return_value = PACKET_DUMP_1
 359         prox = prox_helpers.ProxSocketHelper(mock_socket)
 360         status, ret = prox.get_string()
 361         self.assertEqual(mock_select.select.call_count, 2)
 362         self.assertEqual(ret, 'pktdump,3,11')
 363         self.assertTrue(status)
 364         self.assertEqual(len(prox._pkt_dumps), 1)
 365
 366     @mock.patch.object(prox_helpers, 'select')
 367     def test_get_string3(self, mock_select):
 368         mock_select.select.side_effect = chain([[object()], [None]],
 369                                                repeat([1], 3))
 370         mock_socket = mock.MagicMock()
 371         mock_recv = mock_socket.recv()
 372         mock_recv.decode.return_value = PACKET_DUMP_2
 373         prox = prox_helpers.ProxSocketHelper(mock_socket)
 374         status, ret = prox.get_string()
 375         self.assertTrue(status)
 376         self.assertTrue(mock_select.select.assert_called_once)
 377         self.assertEqual(ret, 'jumped over')
 378         self.assertEqual(len(prox._pkt_dumps), 2)
 379
 380     def test__parse_socket_data_mixed_data(self):
 381         prox = prox_helpers.ProxSocketHelper(mock.MagicMock())
 382         ret, _ = prox._parse_socket_data(PACKET_DUMP_NON_1, False)
 383         self.assertEqual(ret, 'not_a_dump,1,2')
 384         self.assertEqual(len(prox._pkt_dumps), 0)
 385
 386         ret, _ = prox._parse_socket_data(PACKET_DUMP_MIXED_1, False)
 387         self.assertEqual(ret, 'not_a_dump,1,2')
 388         self.assertEqual(len(prox._pkt_dumps), 1)
 389
 390     def test__parse_socket_data_bad_data(self):
 391         prox = prox_helpers.ProxSocketHelper(mock.MagicMock())
 392         with self.assertRaises(ValueError):
 393             prox._parse_socket_data(PACKET_DUMP_BAD_1, False)
 394
 395         with self.assertRaises(ValueError):
 396             prox._parse_socket_data(PACKET_DUMP_BAD_2, False)
 397
 398         ret, _ = prox._parse_socket_data(PACKET_DUMP_BAD_3, False)
 399         self.assertEqual(ret, 'pktdump,3')
 400
 401     def test__parse_socket_data_pkt_dump_only(self):
 402         prox = prox_helpers.ProxSocketHelper(mock.MagicMock())
 403         ret, _ = prox._parse_socket_data('', True)
 404         self.assertFalse(ret)
 405
 406         ret, _ = prox._parse_socket_data(PACKET_DUMP_1, True)
 407         self.assertTrue(ret)
 408
 409         ret, _ = prox._parse_socket_data(PACKET_DUMP_2, True)
 410         self.assertTrue(ret)
 411
 412     def test_put_command(self):
 413         mock_socket = mock.MagicMock()
 414         prox = prox_helpers.ProxSocketHelper(mock_socket)
 415         prox.put_command("data")
 416         mock_socket.sendall.assert_called_once()
 417
 418     def test_put_command_socket_error(self):
 419         mock_socket = mock.MagicMock()
 420         mock_socket.sendall.side_effect = OSError
 421         prox = prox_helpers.ProxSocketHelper(mock_socket)
 422         prox.put_command("data")
 423         mock_socket.sendall.assert_called_once()
 424
 425     def test_get_packet_dump(self):
 426         mock_socket = mock.MagicMock()
 427         prox = prox_helpers.ProxSocketHelper(mock_socket)
 428         prox._pkt_dumps = []
 429         self.assertIsNone(prox.get_packet_dump())
 430
 431         prox._pkt_dumps = [234]
 432         self.assertEqual(prox.get_packet_dump(), 234)
 433         self.assertEqual(prox._pkt_dumps, [])
 434
 435     def test_stop_all_reset(self):
 436         mock_socket = mock.MagicMock()
 437         prox = prox_helpers.ProxSocketHelper(mock_socket)
 438         prox.stop_all_reset()
 439         mock_socket.sendall.assert_called()
 440
 441     def test_stop_all(self):
 442         mock_socket = mock.MagicMock()
 443         prox = prox_helpers.ProxSocketHelper(mock_socket)
 444         prox.stop_all()
 445         mock_socket.sendall.assert_called()
 446
 447     def test_stop(self):
 448         mock_socket = mock.MagicMock()
 449         prox = prox_helpers.ProxSocketHelper(mock_socket)
 450         prox.stop([3, 4, 5], 16)
 451         mock_socket.sendall.assert_called()
 452
 453     def test_start_all(self):
 454         mock_socket = mock.MagicMock()
 455         prox = prox_helpers.ProxSocketHelper(mock_socket)
 456         prox.start_all()
 457         mock_socket.sendall.assert_called()
 458
 459     def test_start(self):
 460         mock_socket = mock.MagicMock()
 461         prox = prox_helpers.ProxSocketHelper(mock_socket)
 462         prox.start([3, 4, 5])
 463         mock_socket.sendall.assert_called()
 464
 465     def test_reset_stats(self):
 466         mock_socket = mock.MagicMock()
 467         prox = prox_helpers.ProxSocketHelper(mock_socket)
 468         prox.reset_stats()
 469         mock_socket.sendall.assert_called()
 470
 471     def test_set_pkt_size(self):
 472         mock_socket = mock.MagicMock()
 473         prox = prox_helpers.ProxSocketHelper(mock_socket)
 474         prox.set_pkt_size([3, 4, 5], 1024)
 475         self.assertEqual(mock_socket.sendall.call_count, 3)
 476
 477     def test_set_value(self):
 478         mock_socket = mock.MagicMock()
 479         prox = prox_helpers.ProxSocketHelper(mock_socket)
 480         prox.set_value([3, 4, 5], 10, 20, 30)
 481         self.assertEqual(mock_socket.sendall.call_count, 3)
 482
 483     def test_reset_values(self):
 484         mock_socket = mock.MagicMock()
 485         prox = prox_helpers.ProxSocketHelper(mock_socket)
 486         prox.reset_values([3, 4, 5])
 487         self.assertEqual(mock_socket.sendall.call_count, 3)
 488
 489     def test_set_speed(self):
 490         mock_socket = mock.MagicMock()
 491         prox = prox_helpers.ProxSocketHelper(mock_socket)
 492         prox.set_speed([3, 4, 5], 1000)
 493         self.assertEqual(mock_socket.sendall.call_count, 3)
 494
 495     def test_slope_speed(self):
 496         core_data = [
 497             {
 498                 'cores': [3, 4, 5],
 499                 'speed': 1000,
 500             },
 501             {
 502                 'cores': [9, 10, 11],
 503                 'speed': '500.5',
 504             },
 505         ]
 506
 507         mock_socket = mock.MagicMock()
 508         prox = prox_helpers.ProxSocketHelper(mock_socket)
 509         prox.set_speed = set_speed = mock.MagicMock()
 510         prox.slope_speed(core_data, 5)
 511         self.assertEqual(set_speed.call_count, 20)
 512
 513         set_speed.reset_mock()
 514         prox.slope_speed(core_data, 5, 5)
 515         self.assertEqual(set_speed.call_count, 10)
 516
 517     def test_set_pps(self):
 518         mock_socket = mock.MagicMock()
 519         prox = prox_helpers.ProxSocketHelper(mock_socket)
 520         prox.set_pps([3, 4, 5], 1000, 512)
 521         self.assertEqual(mock_socket.sendall.call_count, 3)
 522
 523     def test_lat_stats(self):
 524         latency_output = [
 525             '1, 2 , 3',  # has white space
 526             '4,5',  # too short
 527             '7,8,9,10.5,11',  # too long with float, but float is in unused portion
 528             'twelve,13,14',  # value as English word
 529             '15,16.2,17',  # float in used portion
 530         ]
 531
 532         mock_socket = mock.MagicMock()
 533         prox = prox_helpers.ProxSocketHelper(mock_socket)
 534         prox.get_data = mock.MagicMock(side_effect=latency_output)
 535
 536         expected = (
 537             {
 538                 3: 1,
 539                 5: 7,
 540             },
 541             {
 542                 3: 2,
 543                 5: 8,
 544             },
 545             {
 546                 3: 3,
 547                 5: 9,
 548             },
 549         )
 550         result = prox.lat_stats([3, 4, 5, 6, 7], 16)
 551         self.assertEqual(mock_socket.sendall.call_count, 5)
 552         self.assertEqual(result, expected)
 553
 554     def test_get_all_tot_stats_error(self):
 555         mock_socket = mock.MagicMock()
 556         prox = prox_helpers.ProxSocketHelper(mock_socket)
 557         prox.get_data = mock.MagicMock(return_value='3,4,5')
 558         expected = [0, 0, 0, 0]
 559         result = prox.get_all_tot_stats()
 560         self.assertEqual(result, expected)
 561
 562     def test_get_all_tot_stats(self):
 563         mock_socket = mock.MagicMock()
 564         prox = prox_helpers.ProxSocketHelper(mock_socket)
 565         prox.get_data = mock.MagicMock(return_value='3,4,5,6')
 566         expected = 3, 4, 5, 6
 567         result = prox.get_all_tot_stats()
 568         self.assertEqual(result, expected)
 569
 570     def test_hz(self):
 571         mock_socket = mock.MagicMock()
 572         prox = prox_helpers.ProxSocketHelper(mock_socket)
 573         prox.get_data = mock.MagicMock(return_value='3,4,5,6')
 574         expected = 6
 575         result = prox.hz()
 576         self.assertEqual(result, expected)
 577
 578     def test_core_stats(self):
 579         core_stats = [
 580             '3,4,5,6',
 581             '7,8,9,10,NaN',
 582             '11,12,13,14,15',
 583         ]
 584
 585         mock_socket = mock.MagicMock()
 586         prox = prox_helpers.ProxSocketHelper(mock_socket)
 587         prox.get_data = mock.MagicMock(side_effect=core_stats)
 588         expected = 21, 24, 27, 14
 589         result = prox.core_stats([3, 4, 5], 16)
 590         self.assertEqual(result, expected)
 591
 592     @mock.patch.object(prox_helpers.LOG, 'error')
 593     def test_multi_port_stats(self, *args):
 594         mock_socket = mock.MagicMock()
 595         prox = prox_helpers.ProxSocketHelper(mock_socket)
 596         prox.get_string = mock.MagicMock(return_value=(True, '0,1,2,3,4,5;1,1,2,3,4,5'))
 597         expected = [[0, 1, 2, 3, 4, 5], [1, 1, 2, 3, 4, 5]]
 598         status, result = prox.multi_port_stats([0, 1])
 599         self.assertEqual(result, expected)
 600         self.assertEqual(status, True)
 601
 602         prox.get_string = mock.MagicMock(
 603             return_value=(True, '0,1,2,3,4,5;1,1,2,3,4,5'))
 604         status, result = prox.multi_port_stats([0])
 605         self.assertEqual(status, False)
 606
 607         prox.get_string = mock.MagicMock(
 608             return_value=(True, '0,1,2,3,4,5;1,1,2,3,4,5'))
 609         status, result = prox.multi_port_stats([0, 1, 2])
 610         self.assertEqual(status, False)
 611
 612         prox.get_string = mock.MagicMock(
 613             return_value=(True, '0,1,2,3;1,1,2,3,4,5'))
 614         status, result = prox.multi_port_stats([0, 1])
 615         self.assertEqual(status, False)
 616
 617         prox.get_string = mock.MagicMock(
 618             return_value=(True, '99,1,2,3,4,5;1,1,2,3,4,5'))
 619         status, result = prox.multi_port_stats([0, 1])
 620         self.assertEqual(status, False)
 621
 622         prox.get_string = mock.MagicMock(
 623             return_value=(True, '99,1,2,3,4,5;1,1,2,3,4,5'))
 624         status, result = prox.multi_port_stats([99, 1])
 625         expected = [[99, 1, 2, 3, 4, 5], [1, 1, 2, 3, 4, 5]]
 626         self.assertEqual(status, True)
 627         self.assertEqual(result, expected)
 628
 629         prox.get_string = mock.MagicMock(
 630             return_value=(True,
 631                           '2,21,22,23,24,25;1,11,12,13,14,15;0,1,2,3,4,5'))
 632
 633         sample1 = [0, 1, 2, 3, 4, 5]
 634         sample2 = [1, 11, 12, 13, 14, 15]
 635         sample3 = [2, 21, 22, 23, 24, 25]
 636         expected = [sample3, sample2, sample1]
 637         status, result = prox.multi_port_stats([1, 2, 0])
 638         self.assertTrue(status)
 639         self.assertListEqual(result, expected)
 640
 641         prox.get_string = mock.MagicMock(
 642             return_value=(True, '6,21,22,23,24,25;1,11,12,13,14,15;0,1,2,3,4,5'))
 643         ok, result = prox.multi_port_stats([1, 6, 0])
 644         sample1 = [6, 21, 22, 23, 24, 25]
 645         sample2 = [1, 11, 12, 13, 14, 15]
 646         sample3 = [0, 1, 2, 3, 4, 5]
 647         expected = [sample1, sample2, sample3]
 648         self.assertListEqual(result, expected)
 649         self.assertTrue(ok)
 650
 651     def test_port_stats(self):
 652         port_stats = [
 653             ','.join(str(n) for n in range(3, 15)),
 654             ','.join(str(n) for n in range(8, 32, 2)),
 655             ','.join(str(n) for n in range(5, 89, 7)),
 656         ]
 657
 658         mock_socket = mock.MagicMock()
 659         prox = prox_helpers.ProxSocketHelper(mock_socket)
 660         prox.get_data = mock.MagicMock(side_effect=port_stats)
 661         expected = [16, 26, 36, 46, 56, 66, 76, 86, 96, 106, 116, 126]
 662         result = prox.port_stats([3, 4, 5])
 663         self.assertEqual(result, expected)
 664
 665     def test_measure_tot_stats(self):
 666         start_tot = 3, 4, 5, 6
 667         end_tot = 7, 9, 11, 13
 668         delta_tot = 4, 5, 6, 7
 669
 670         get_data_output = [
 671             ','.join(str(n) for n in start_tot),
 672             ','.join(str(n) for n in end_tot),
 673         ]
 674
 675         mock_socket = mock.MagicMock()
 676         prox = prox_helpers.ProxSocketHelper(mock_socket)
 677         prox.get_data = mock.MagicMock(side_effect=get_data_output)
 678         expected = {
 679             'start_tot': start_tot,
 680             'end_tot': end_tot,
 681             'delta': delta_tot,
 682         }
 683         with prox.measure_tot_stats() as result:
 684             pass
 685         self.assertEqual(result, expected)
 686
 687     def test_tot_stats(self):
 688         mock_socket = mock.MagicMock()
 689         prox = prox_helpers.ProxSocketHelper(mock_socket)
 690         prox.get_data = mock.MagicMock(return_value='3,4,5,6')
 691         expected = 3, 4, 5
 692         result = prox.tot_stats()
 693         self.assertEqual(result, expected)
 694
 695     def test_tot_ierrors(self):
 696         mock_socket = mock.MagicMock()
 697         prox = prox_helpers.ProxSocketHelper(mock_socket)
 698         prox.get_data = mock.MagicMock(return_value='3,4,5,6')
 699         expected = 3, 3
 700         result = prox.tot_ierrors()
 701         self.assertEqual(result, expected)
 702
 703     def test_set_count(self):
 704         mock_socket = mock.MagicMock()
 705         prox = prox_helpers.ProxSocketHelper(mock_socket)
 706         prox.set_count(432, [3, 4, 5])
 707         self.assertEqual(mock_socket.sendall.call_count, 3)
 708
 709     def test_dump_rx(self):
 710         mock_socket = mock.MagicMock()
 711         prox = prox_helpers.ProxSocketHelper(mock_socket)
 712         prox.dump_rx(3, 5, 8)
 713         mock_socket.sendall.assert_called_once()
 714
 715     def test_quit(self):
 716         mock_socket = mock.MagicMock()
 717         prox = prox_helpers.ProxSocketHelper(mock_socket)
 718         prox.quit()
 719         mock_socket.sendall.assert_called()
 720
 721     def test_force_quit(self):
 722         mock_socket = mock.MagicMock()
 723         prox = prox_helpers.ProxSocketHelper(mock_socket)
 724         prox.force_quit()
 725         mock_socket.sendall.assert_called()
 726
 727
 728 class TestProxDpdkVnfSetupEnvHelper(unittest.TestCase):
 729
 730     VNFD0 = {
 731         'short-name': 'ProxVnf',
 732         'vdu': [
 733             {
 734                 'routing_table': [
 735                     {
 736                         'network': '152.16.100.20',
 737                         'netmask': '255.255.255.0',
 738                         'gateway': '152.16.100.20',
 739                         'if': 'xe0',
 740                     },
 741                     {
 742                         'network': '152.16.40.20',
 743                         'netmask': '255.255.255.0',
 744                         'gateway': '152.16.40.20',
 745                         'if': 'xe1',
 746                     },
 747                 ],
 748                 'description': 'PROX approximation using DPDK',
 749                 'name': 'proxvnf-baremetal',
 750                 'nd_route_tbl': [
 751                     {
 752                         'network': '0064:ff9b:0:0:0:0:9810:6414',
 753                         'netmask': '112',
 754                         'gateway': '0064:ff9b:0:0:0:0:9810:6414',
 755                         'if': 'xe0',
 756                     },
 757                     {
 758                         'network': '0064:ff9b:0:0:0:0:9810:2814',
 759                         'netmask': '112',
 760                         'gateway': '0064:ff9b:0:0:0:0:9810:2814',
 761                         'if': 'xe1',
 762                     },
 763                 ],
 764                 'id': 'proxvnf-baremetal',
 765                 'external-interface': [
 766                     {
 767                         'virtual-interface': {
 768                             'dst_mac': '00:00:00:00:00:04',
 769                             'vpci': '0000:05:00.0',
 770                             'local_ip': '152.16.100.19',
 771                             'type': 'PCI-PASSTHROUGH',
 772                             'vld_id': 'uplink_0',
 773                             'netmask': '255.255.255.0',
 774                             'dpdk_port_num': 0,
 775                             'bandwidth': '10 Gbps',
 776                             'driver': "i40e",
 777                             'dst_ip': '152.16.100.19',
 778                             'local_iface_name': 'xe0',
 779                             'local_mac': '00:00:00:00:00:02',
 780                             'ifname': 'xe0',
 781                         },
 782                         'vnfd-connection-point-ref': 'xe0',
 783                         'name': 'xe0',
 784                     },
 785                     {
 786                         'virtual-interface': {
 787                             'dst_mac': '00:00:00:00:00:03',
 788                             'vpci': '0000:05:00.1',
 789                             'local_ip': '152.16.40.19',
 790                             'type': 'PCI-PASSTHROUGH',
 791                             'vld_id': 'downlink_0',
 792                             'driver': "i40e",
 793                             'netmask': '255.255.255.0',
 794                             'dpdk_port_num': 1,
 795                             'bandwidth': '10 Gbps',
 796                             'dst_ip': '152.16.40.20',
 797                             'local_iface_name': 'xe1',
 798                             'local_mac': '00:00:00:00:00:01',
 799                             'ifname': 'xe1',
 800                         },
 801                         'vnfd-connection-point-ref': 'xe1',
 802                         'name': 'xe1',
 803                     },
 804                 ],
 805             },
 806         ],
 807         'description': 'PROX approximation using DPDK',
 808         'mgmt-interface': {
 809             'vdu-id': 'proxvnf-baremetal',
 810             'host': '1.2.1.1',
 811             'password': 'r00t',
 812             'user': 'root',
 813             'ip': '1.2.1.1',
 814         },
 815         'benchmark': {
 816             'kpi': [
 817                 'packets_in',
 818                 'packets_fwd',
 819                 'packets_dropped',
 820             ],
 821         },
 822         'id': 'ProxApproxVnf',
 823         'name': 'ProxVnf',
 824     }
 825
 826     VNFD = {
 827         'vnfd:vnfd-catalog': {
 828             'vnfd': [
 829                 VNFD0,
 830             ],
 831         },
 832     }
 833
 834     def test_global_section(self):
 835         setup_helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
 836             mock.MagicMock(), mock.MagicMock(), mock.MagicMock())
 837
 838         setup_helper._prox_config_data = [('a', [])]
 839
 840         with self.assertRaises(KeyError):
 841             _ = setup_helper.global_section
 842
 843         global_section = (
 844             'global', [
 845                 ('not_name', 'other data'),
 846                 ('name_not', 'more data'),
 847                 ('name', 'prox type'),
 848             ],
 849         )
 850
 851         setup_helper._prox_config_data = [
 852             ('section1', []),
 853             ('section2', [
 854                 ('a', 'b'),
 855                 ('c', 'd'),
 856             ]),
 857             ('core 1', []),
 858             ('core 2', [
 859                 ('index', 8),
 860                 ('mode', ''),
 861             ]),
 862             global_section,
 863             ('core 3', [
 864                 ('index', 5),
 865                 ('mode', 'gen'),
 866                 ('name', 'tagged'),
 867             ]),
 868             ('section3', [
 869                 ('key1', 'value1'),
 870                 ('key2', 'value2'),
 871                 ('key3', 'value3'),
 872             ]),
 873             ('core 4', [
 874                 ('index', 7),
 875                 ('mode', 'gen'),
 876                 ('name', 'udp'),
 877             ]),
 878         ]
 879
 880         result = setup_helper.global_section
 881         self.assertEqual(result, global_section[1])
 882
 883     def test_find_in_section(self):
 884         setup_helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
 885             mock.MagicMock(), mock.MagicMock(), mock.MagicMock())
 886
 887         setup_helper._prox_config_data = [
 888             ('global', [
 889                 ('not_name', 'other data'),
 890                 ('name_not', 'more data'),
 891                 ('name', 'prox type'),
 892             ]),
 893             ('section1', []),
 894             ('section2', [
 895                 ('a', 'b'),
 896                 ('c', 'd'),
 897             ]),
 898             ('core 1', []),
 899             ('core 2', [
 900                 ('index', 8),
 901                 ('mode', ''),
 902             ]),
 903             ('core 3', [
 904                 ('index', 5),
 905                 ('mode', 'gen'),
 906                 ('name', 'tagged'),
 907             ]),
 908             ('section3', [
 909                 ('key1', 'value1'),
 910                 ('key2', 'value2'),
 911                 ('key3', 'value3'),
 912             ]),
 913             ('core 4', [
 914                 ('index', 7),
 915                 ('mode', 'gen'),
 916                 ('name', 'udp'),
 917             ]),
 918         ]
 919
 920         expected = 'value3'
 921         result = setup_helper.find_in_section('section3', 'key3')
 922         self.assertEqual(result, expected)
 923
 924         expected = 'default value'
 925         result = setup_helper.find_in_section('section3', 'key4', 'default value')
 926         self.assertEqual(result, expected)
 927
 928         with self.assertRaises(KeyError):
 929             setup_helper.find_in_section('section4', 'key1')
 930
 931         with self.assertRaises(KeyError):
 932             setup_helper.find_in_section('section1', 'key1')
 933
 934     def test__replace_quoted_with_value(self):
 935         # empty string
 936         input_str = ''
 937         expected = ''
 938         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
 939                   _replace_quoted_with_value(input_str, 'cat'))
 940         self.assertEqual(result, expected)
 941
 942         # no quoted substring
 943         input_str = 'lion tiger bear'
 944         expected = 'lion tiger bear'
 945         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
 946                   _replace_quoted_with_value(input_str, 'cat'))
 947         self.assertEqual(result, expected)
 948
 949         # partially quoted substring
 950         input_str = 'lion "tiger bear'
 951         expected = 'lion "tiger bear'
 952         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
 953                   _replace_quoted_with_value(input_str, 'cat'))
 954         self.assertEqual(result, expected)
 955
 956         # one quoted substring
 957         input_str = 'lion "tiger" bear'
 958         expected = 'lion "cat" bear'
 959         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
 960                   _replace_quoted_with_value(input_str, 'cat'))
 961         self.assertEqual(result, expected)
 962
 963         # two quoted substrings
 964         input_str = 'lion "tiger" bear "shark" whale'
 965         expected = 'lion "cat" bear "shark" whale'
 966         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
 967                   _replace_quoted_with_value(input_str, 'cat'))
 968         self.assertEqual(result, expected)
 969
 970         # two quoted substrings, both replaced
 971         input_str = 'lion "tiger" bear "shark" whale'
 972         expected = 'lion "cat" bear "cat" whale'
 973         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
 974                   _replace_quoted_with_value(input_str, 'cat', 2))
 975         self.assertEqual(result, expected)
 976
 977     def test__get_tx_port(self):
 978         # no data
 979         input_data = {'section1': []}
 980         expected = -1
 981         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
 982                   _get_tx_port('section1', input_data))
 983         self.assertEqual(result, expected)
 984
 985         # data for other section
 986         input_data = {
 987             'section1': [],
 988             'section2': [
 989                 ('rx port', '3'),
 990                 ('tx port', '4'),
 991             ],
 992         }
 993         expected = -1
 994         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
 995                   _get_tx_port('section1', input_data))
 996         self.assertEqual(result, expected)
 997
 998         # data for section
 999         input_data['section1'] = section1 = [
1000             ('rx port', '4', 'more', 432),
1001             ('tx port', '3'),
1002         ]
1003         expected = 3
1004         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1005                   _get_tx_port('section1', input_data))
1006         self.assertEqual(result, expected)
1007
1008         # more data for section,
1009         section1.extend([
1010             ('rx port', '2'),
1011             ('tx port', '1', 'and more', 234),
1012         ])
1013         expected = 1
1014         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1015                   _get_tx_port('section1', input_data))
1016         self.assertEqual(result, expected)
1017
1018     # TODO(elfoley): Split this into several smaller tests
1019     def test_write_prox_config(self):
1020         input_data = {}
1021         expected = ''
1022         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1023                   write_prox_config(input_data))
1024         self.assertEqual(result, expected)
1025
1026         input_data = [
1027             [
1028                 'section1',
1029                 [],
1030             ],
1031         ]
1032         expected = '[section1]'
1033         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1034                   write_prox_config(input_data))
1035         self.assertEqual(result, expected)
1036
1037         input_data = [
1038             [
1039                 'section1',
1040                 [],
1041             ],
1042             [
1043                 'section2',
1044                 [
1045                     ['key1', 'value1'],
1046                     ['__name__', 'not this one'],
1047                     ['key2', None],
1048                     ['key3', 234],
1049                     ['key4', 'multi-line\nvalue'],
1050                 ],
1051             ],
1052         ]
1053         expected = os.linesep.join([
1054             '[section1]',
1055             '[section2]',
1056             'key1=value1',
1057             'key2',
1058             'key3=234',
1059             'key4=multi-line\n\tvalue',
1060         ])
1061         result = (prox_helpers.ProxDpdkVnfSetupEnvHelper.
1062                   write_prox_config(input_data))
1063         self.assertEqual(result, expected)
1064
1065     def test_prox_config_data(self):
1066         setup_helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1067             mock.MagicMock(), mock.MagicMock(), mock.MagicMock())
1068
1069         setup_helper.config_queue = config_queue = mock.MagicMock()
1070         config_queue.get.return_value = expected = [('s', [('a', 3), ('b', 45)])]
1071
1072         result = setup_helper.prox_config_data
1073         self.assertEqual(result, expected)
1074
1075     @mock.patch.object(utils, 'find_relative_file')
1076     def test_build_config_file_no_additional_file(self, mock_find_path):
1077         vnf1 = {
1078             'prox_args': {'-c': ""},
1079             'prox_path': 'd',
1080             'prox_config': 'e/f',
1081             'prox_generate_parameter': False,
1082         }
1083
1084         mock_find_path.side_effect = ['1', '2']
1085
1086         vnfd_helper = mock.MagicMock()
1087         ssh_helper = mock.MagicMock()
1088         scenario_helper = sample_vnf.ScenarioHelper('vnf1')
1089         scenario_helper.scenario_cfg = {
1090             'task_path': 'a/b',
1091             'options': {
1092                 'vnf1': vnf1,
1093             },
1094         }
1095
1096         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1097             vnfd_helper, ssh_helper, scenario_helper)
1098         helper.copy_to_target = mock.MagicMock(return_value='3')
1099         helper.generate_prox_config_file = mock.MagicMock(return_value='4')
1100         helper.upload_prox_config = mock.MagicMock(return_value='5')
1101
1102         self.assertEqual(helper.additional_files, {})
1103         self.assertNotEqual(helper._prox_config_data, '4')
1104         self.assertNotEqual(helper.remote_path, '5')
1105         helper.build_config_file()
1106         self.assertEqual(helper.additional_files, {})
1107         self.assertEqual(helper._prox_config_data, '4')
1108         self.assertEqual(helper.remote_path, '5')
1109
1110     @mock.patch.object(utils, 'find_relative_file')
1111     def test_build_config_file_additional_file_string(self, mock_find_path):
1112         vnf1 = {
1113             'prox_args': {'-c': ""},
1114             'prox_path': 'd',
1115             'prox_config': 'e/f',
1116             'prox_files': 'g/h.i',
1117             'prox_generate_parameter': True,
1118         }
1119
1120         mock_find_path.side_effect = ['1', '2']
1121         vnfd_helper = mock.MagicMock()
1122         ssh_helper = mock.MagicMock()
1123         scenario_helper = sample_vnf.ScenarioHelper('vnf1')
1124         scenario_helper.scenario_cfg = {
1125             'task_path': 'a/b',
1126             'options': {
1127                 'vnf1': vnf1,
1128             },
1129         }
1130
1131         vnfd_helper.port_pairs.all_ports = ['xe0', 'xe1', 'xe2', 'xe3']
1132         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1133             vnfd_helper, ssh_helper, scenario_helper)
1134         helper.copy_to_target = mock.MagicMock(side_effect=['33', '34', '35'])
1135         helper.generate_prox_config_file = mock.MagicMock(return_value='44')
1136         helper.upload_prox_config = mock.MagicMock(return_value='55')
1137
1138         self.assertEqual(helper.additional_files, {})
1139         expected = {'h.i': '33'}
1140         helper.build_config_file()
1141         self.assertDictEqual(helper.additional_files, expected)
1142
1143     @mock.patch.object(utils, 'find_relative_file')
1144     def test_build_config_file_additional_file(self, mock_find_path):
1145         vnf1 = {
1146             'prox_args': {'-c': ""},
1147             'prox_path': 'd',
1148             'prox_config': 'e/f',
1149             'prox_files': [
1150                 'g/h.i',
1151                 'j/k/l',
1152                 'm_n',
1153             ],
1154         }
1155
1156         mock_find_path.side_effect = ['1', '2'] + [str(i) for i in range(len(vnf1['prox_files']))]
1157         vnfd_helper = mock.MagicMock()
1158         ssh_helper = mock.MagicMock()
1159         scenario_helper = sample_vnf.ScenarioHelper('vnf1')
1160         scenario_helper.scenario_cfg = {
1161             'task_path': 'a/b',
1162             'options': {
1163                 'vnf1': vnf1,
1164             },
1165         }
1166
1167         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1168             vnfd_helper, ssh_helper, scenario_helper)
1169         helper.copy_to_target = mock.MagicMock(side_effect=['33', '34', '35'])
1170         helper.generate_prox_config_file = mock.MagicMock(return_value='44')
1171         helper.upload_prox_config = mock.MagicMock(return_value='55')
1172
1173         self.assertEqual(helper.additional_files, {})
1174         self.assertNotEqual(helper._prox_config_data, '44')
1175         self.assertNotEqual(helper.remote_path, '55')
1176         expected = {'h.i': '33', 'l': '34', 'm_n': '35'}
1177         helper.build_config_file()
1178         self.assertDictEqual(helper.additional_files, expected)
1179         self.assertEqual(helper._prox_config_data, '44')
1180         self.assertEqual(helper.remote_path, '55')
1181
1182     def test_build_config(self):
1183         vnf1 = {
1184             'prox_args': {'-f': ""},
1185             'prox_path': '/opt/nsb_bin/prox',
1186             'prox_config': 'configs/gen_l2fwd-2.cfg',
1187             'prox_files': [
1188                 'g/h.i',
1189                 'j/k/l',
1190                 'm_n',
1191             ],
1192         }
1193
1194         vnfd_helper = mock.Mock()
1195         ssh_helper = mock.Mock()
1196         ssh_helper.join_bin_path.return_value = '/opt/nsb_bin/prox'
1197         scenario_helper = sample_vnf.ScenarioHelper('vnf1')
1198         scenario_helper.scenario_cfg = {
1199             'task_path': 'a/b',
1200             'options': {
1201                 'vnf1': vnf1,
1202             },
1203         }
1204
1205         expected = ("sudo bash -c 'cd /opt/nsb_bin; /opt/nsb_bin/prox -o cli "
1206                     "-f  -f /tmp/prox.cfg '")
1207
1208         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1209             vnfd_helper, ssh_helper, scenario_helper)
1210         with mock.patch.object(helper, 'build_config_file') as mock_cfg_file:
1211             helper.remote_path = '/tmp/prox.cfg'
1212             prox_cmd = helper.build_config()
1213             self.assertEqual(prox_cmd, expected)
1214             mock_cfg_file.assert_called_once()
1215
1216     def test__insert_additional_file(self):
1217         vnfd_helper = mock.MagicMock()
1218         ssh_helper = mock.MagicMock()
1219         scenario_helper = mock.MagicMock()
1220
1221         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1222             vnfd_helper, ssh_helper, scenario_helper)
1223         helper.additional_files = {"ipv4.lua": "/tmp/ipv4.lua"}
1224         res = helper._insert_additional_file('dofile("ipv4.lua")')
1225         self.assertEqual(res, 'dofile("/tmp/ipv4.lua")')
1226
1227     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ConfigParser')
1228     def test_generate_prox_config_file(self, mock_parser_type):
1229         def init(*args):
1230             if sections_data:
1231                 args[-1].extend(sections_data)
1232             return mock.MagicMock()
1233
1234         sections_data = []
1235
1236         mock_parser_type.side_effect = init
1237
1238         vnfd_helper = vnf_base.VnfdHelper(self.VNFD0)
1239         ssh_helper = mock.MagicMock()
1240         scenario_helper = mock.MagicMock()
1241
1242         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1243             vnfd_helper, ssh_helper, scenario_helper)
1244         helper.additional_files = {}
1245
1246         expected = []
1247         result = helper.generate_prox_config_file('a/b')
1248         self.assertEqual(result, expected)
1249
1250         helper.additional_files = {"ipv4.lua": "/tmp/ipv4.lua"}
1251
1252         helper.remote_prox_file_name = 'remote'
1253         sections_data = [
1254             [
1255                 'lua',
1256                 [
1257                     ['dofile("ipv4.lua")', ''],
1258                 ],
1259             ],
1260             [
1261                 'port 0',
1262                 [
1263                     ['ip', ''],
1264                     ['mac', 'foo'],
1265                     ['dst mac', '@@1'],
1266                     ['tx port', '1'],
1267                 ],
1268             ],
1269             [
1270                 'port 2',
1271                 [
1272                     ['ip', ''],
1273                     ['$sut_mac0', '@@dst_mac0'],
1274                     ['tx port', '0'],
1275                     ['single', '@'],
1276                     ['user_table', 'dofile("ipv4.lua")'],
1277                     ['missing_addtional_file', 'dofile("nosuch")'],
1278                 ],
1279             ],
1280         ]
1281
1282         expected = [
1283             [
1284                 'lua',
1285                 [
1286                     ['dofile("/tmp/ipv4.lua")', ''],
1287                 ],
1288             ],
1289             [
1290                 'port 0',
1291                 [
1292                     ['ip', ''],
1293                     ['mac', 'hardware'],
1294                     ['dst mac', '00:00:00:00:00:03'],
1295                     ['tx port', '1'],
1296                 ],
1297             ],
1298             [
1299                 'port 2',
1300                 [
1301                     ['ip', ''],
1302                     ['$sut_mac0', '00 00 00 00 00 04'],
1303                     ['tx port', '0'],
1304                     ['single', '@'],
1305                     ['user_table', 'dofile("/tmp/ipv4.lua")'],
1306                     ['missing_addtional_file', 'dofile("nosuch")'],
1307                 ],
1308             ],
1309         ]
1310         result = helper.generate_prox_config_file('/c/d/e')
1311         self.assertEqual(result, expected, str(result))
1312
1313     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ConfigParser')
1314     def test_generate_prox_config_file_negative(self, mock_parser_type):
1315         def init(*args):
1316             args[-1].update(sections_data)
1317             return mock.MagicMock()
1318
1319         sections_data = {}
1320
1321         mock_parser_type.side_effect = init
1322
1323         vnfd_helper = mock.MagicMock()
1324         vnfd_helper.interfaces = []
1325         ssh_helper = mock.MagicMock()
1326         scenario_helper = mock.MagicMock()
1327
1328         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1329             vnfd_helper, ssh_helper, scenario_helper)
1330         helper.additional_files = {}
1331         helper.remote_prox_file_name = 'remote'
1332         vnfd_helper.interfaces = [
1333             {
1334                 'virtual-interface': {
1335                     'dpdk_port_num': 3,
1336                     'dst_mac': '00:00:00:de:ad:88',
1337                 },
1338             },
1339             {
1340                 'virtual-interface': {
1341                     'dpdk_port_num': 5,
1342                     'dst_mac': '00:00:00:de:ad:ff',
1343                 },
1344             },
1345             {
1346                 'virtual-interface': {
1347                     'dpdk_port_num': 7,
1348                     'dst_mac': '00:00:00:de:ad:ff',
1349                 },
1350             },
1351         ]
1352         sections_data = {
1353             'port 3': [
1354                 ['ip', ''],
1355                 ['mac', 'foo'],
1356                 ['dst mac', ''],
1357             ],
1358             'port 5': [
1359                 ['ip', ''],
1360                 ['dst mac', ''],
1361                 ['tx port', '0'],
1362                 ['???', 'dofile "here" 23'],
1363             ],
1364         }
1365
1366         with self.assertRaises(Exception):
1367             helper.generate_prox_config_file('a/b')
1368
1369     def test_put_string_to_file(self):
1370         vnfd_helper = mock.MagicMock()
1371         vnfd_helper.interfaces = []
1372         ssh_helper = mock.MagicMock()
1373         scenario_helper = mock.MagicMock()
1374
1375         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1376             vnfd_helper, ssh_helper, scenario_helper)
1377
1378         expected = 'a/b'
1379         result = helper.put_string_to_file('my long string', 'a/b')
1380         self.assertEqual(result, expected)
1381
1382     def test_copy_to_target(self):
1383         vnfd_helper = mock.MagicMock()
1384         vnfd_helper.interfaces = []
1385         ssh_helper = mock.MagicMock()
1386         scenario_helper = mock.MagicMock()
1387
1388         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1389             vnfd_helper, ssh_helper, scenario_helper)
1390         expected = '/tmp/c'
1391         result = helper.copy_to_target('a/b', 'c')
1392         self.assertEqual(result, expected)
1393
1394     def test_upload_prox_config(self):
1395         vnfd_helper = mock.MagicMock()
1396         vnfd_helper.interfaces = []
1397         ssh_helper = mock.MagicMock()
1398         scenario_helper = mock.MagicMock()
1399
1400         helper = prox_helpers.ProxDpdkVnfSetupEnvHelper(
1401             vnfd_helper, ssh_helper, scenario_helper)
1402         helper.write_prox_config = mock.MagicMock(return_value='a long string')
1403         expected = '/tmp/a'
1404         result = helper.upload_prox_config('a', {})
1405         self.assertEqual(result, expected)
1406
1407
1408 class TestProxResourceHelper(unittest.TestCase):
1409
1410     VNFD0 = {
1411         'short-name': 'ProxVnf',
1412         'vdu': [
1413             {
1414                 'routing_table': [
1415                     {
1416                         'network': '152.16.100.20',
1417                         'netmask': '255.255.255.0',
1418                         'gateway': '152.16.100.20',
1419                         'if': 'xe0',
1420                     },
1421                     {
1422                         'network': '152.16.40.20',
1423                         'netmask': '255.255.255.0',
1424                         'gateway': '152.16.40.20',
1425                         'if': 'xe1',
1426                     },
1427                 ],
1428                 'description': 'PROX approximation using DPDK',
1429                 'name': 'proxvnf-baremetal',
1430                 'nd_route_tbl': [
1431                     {
1432                         'network': '0064:ff9b:0:0:0:0:9810:6414',
1433                         'netmask': '112',
1434                         'gateway': '0064:ff9b:0:0:0:0:9810:6414',
1435                         'if': 'xe0',
1436                     },
1437                     {
1438                         'network': '0064:ff9b:0:0:0:0:9810:2814',
1439                         'netmask': '112',
1440                         'gateway': '0064:ff9b:0:0:0:0:9810:2814',
1441                         'if': 'xe1',
1442                     },
1443                 ],
1444                 'id': 'proxvnf-baremetal',
1445                 'external-interface': [
1446                     {
1447                         'virtual-interface': {
1448                             'dst_mac': '00:00:00:00:00:04',
1449                             'vpci': '0000:05:00.0',
1450                             'local_ip': '152.16.100.19',
1451                             'type': 'PCI-PASSTHROUGH',
1452                             'vld_id': 'uplink_0',
1453                             'netmask': '255.255.255.0',
1454                             'dpdk_port_num': 0,
1455                             'bandwidth': '10 Gbps',
1456                             'driver': "i40e",
1457                             'dst_ip': '152.16.100.19',
1458                             'local_iface_name': 'xe0',
1459                             'local_mac': '00:00:00:00:00:02',
1460                             'ifname': 'xe0',
1461                         },
1462                         'vnfd-connection-point-ref': 'xe0',
1463                         'name': 'xe0',
1464                     },
1465                     {
1466                         'virtual-interface': {
1467                             'dst_mac': '00:00:00:00:00:03',
1468                             'vpci': '0000:05:00.1',
1469                             'local_ip': '152.16.40.19',
1470                             'type': 'PCI-PASSTHROUGH',
1471                             'vld_id': 'downlink_0',
1472                             'driver': "i40e",
1473                             'netmask': '255.255.255.0',
1474                             'dpdk_port_num': 1,
1475                             'bandwidth': '10 Gbps',
1476                             'dst_ip': '152.16.40.20',
1477                             'local_iface_name': 'xe1',
1478                             'local_mac': '00:00:00:00:00:01',
1479                             'ifname': 'xe1',
1480                         },
1481                         'vnfd-connection-point-ref': 'xe1',
1482                         'name': 'xe1',
1483                     },
1484                 ],
1485             },
1486         ],
1487         'description': 'PROX approximation using DPDK',
1488         'mgmt-interface': {
1489             'vdu-id': 'proxvnf-baremetal',
1490             'host': '1.2.1.1',
1491             'password': 'r00t',
1492             'user': 'root',
1493             'ip': '1.2.1.1',
1494         },
1495         'benchmark': {
1496             'kpi': [
1497                 'packets_in',
1498                 'packets_fwd',
1499                 'packets_dropped',
1500             ],
1501         },
1502         'id': 'ProxApproxVnf',
1503         'name': 'ProxVnf',
1504     }
1505
1506     VNFD = {
1507         'vnfd:vnfd-catalog': {
1508             'vnfd': [
1509                 VNFD0,
1510             ],
1511         },
1512     }
1513
1514     def test_find_pci(self):
1515         input_str_list = [
1516             'no target here',
1517             'nor here',
1518             'and still not',
1519         ]
1520         result = prox_helpers.ProxResourceHelper.find_pci('target',
1521                                                           input_str_list)
1522         self.assertFalse(result)
1523
1524         input_str_list = [
1525             'no target here',
1526             'nor here',
1527             'this is a target',
1528             'did we miss it',
1529         ]
1530         result = prox_helpers.ProxResourceHelper.find_pci('target',
1531                                                           input_str_list)
1532         self.assertTrue(result)
1533
1534     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.RETRY_INTERVAL', 0)
1535     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ProxSocketHelper')
1536     def test_sut(self, *args):
1537         helper = prox_helpers.ProxResourceHelper(mock.MagicMock())
1538         self.assertIsNone(helper.client)
1539         result = helper.sut
1540         self.assertIsNotNone(result)
1541         self.assertIs(result, helper.client)
1542         self.assertIs(result, helper.sut)
1543
1544     def test_test_type(self):
1545         setup_helper = mock.MagicMock()
1546         setup_helper.find_in_section.return_value = expected = 'prox type'
1547
1548         helper = prox_helpers.ProxResourceHelper(setup_helper)
1549
1550         self.assertIsNone(helper._test_type)
1551         self.assertEqual(helper.test_type, expected)
1552         self.assertEqual(helper._test_type, expected)
1553         self.assertEqual(helper.test_type, expected)
1554
1555     def test_collect_collectd_kpi(self):
1556         helper = prox_helpers.ProxResourceHelper(mock.MagicMock())
1557         helper.resource = resource = mock.MagicMock()
1558
1559         resource.check_if_system_agent_running.return_value = 0, '1234'
1560         resource.amqp_collect_nfvi_kpi.return_value = 543
1561         resource.check_if_system_agent_running.return_value = (0, None)
1562
1563         expected = {'core': 543}
1564         result = helper.collect_collectd_kpi()
1565         self.assertDictEqual(result, expected)
1566
1567     def test_collect_kpi(self):
1568         helper = prox_helpers.ProxResourceHelper(mock.MagicMock())
1569         helper._queue = queue = mock.MagicMock()
1570         helper._result = {'z': 123}
1571         helper.resource = resource = mock.MagicMock()
1572
1573         resource.check_if_system_agent_running.return_value = 0, '1234'
1574         resource.amqp_collect_nfvi_kpi.return_value = 543
1575         resource.check_if_system_agent_running.return_value = (0, None)
1576
1577         queue.empty.return_value = False
1578         queue.get.return_value = {'a': 789}
1579
1580         expected = {'z': 123, 'a': 789, 'collect_stats': {'core': 543}}
1581         result = helper.collect_kpi()
1582         self.assertDictEqual(result, expected)
1583
1584     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
1585     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ProxSocketHelper')
1586     def test__connect(self, mock_socket_helper_type, *args):
1587         client = mock_socket_helper_type()
1588         client.connect.side_effect = chain(repeat(socket.error, 5), [None])
1589
1590         setup_helper = mock.MagicMock()
1591         setup_helper.vnfd_helper.interfaces = []
1592
1593         helper = prox_helpers.ProxResourceHelper(setup_helper)
1594
1595         result = helper._connect()
1596         self.assertIs(result, client)
1597
1598         client.connect.side_effect = chain(repeat(socket.error, 65), [None])
1599
1600         with self.assertRaises(Exception):
1601             helper._connect()
1602
1603     def test_run_traffic(self):
1604         setup_helper = mock.MagicMock()
1605         helper = prox_helpers.ProxResourceHelper(setup_helper)
1606         traffic_profile = mock.MagicMock()
1607         traffic_profile.done.is_set.return_value = True
1608         helper.run_traffic(traffic_profile)
1609         self.assertEqual(helper._terminated.value, 1)
1610
1611     def test__run_traffic_once(self):
1612         setup_helper = mock.MagicMock()
1613         helper = prox_helpers.ProxResourceHelper(setup_helper)
1614         traffic_profile = mock.MagicMock()
1615         traffic_profile.done.is_set.return_value = True
1616         helper._run_traffic_once(traffic_profile)
1617         self.assertEqual(helper._terminated.value, 1)
1618
1619     def test_start_collect(self):
1620         setup_helper = mock.MagicMock()
1621         helper = prox_helpers.ProxResourceHelper(setup_helper)
1622         helper.resource = resource = mock.MagicMock()
1623         self.assertIsNone(helper.start_collect())
1624         resource.start.assert_called_once()
1625
1626     def test_terminate(self):
1627         setup_helper = mock.MagicMock()
1628         helper = prox_helpers.ProxResourceHelper(setup_helper)
1629         with self.assertRaises(NotImplementedError):
1630             helper.terminate()
1631
1632     def test_up_post(self):
1633         setup_helper = mock.MagicMock()
1634         helper = prox_helpers.ProxResourceHelper(setup_helper)
1635         helper.client = expected = mock.MagicMock()
1636         result = helper.up_post()
1637         self.assertEqual(result, expected)
1638
1639     def test_execute(self):
1640         setup_helper = mock.MagicMock()
1641         helper = prox_helpers.ProxResourceHelper(setup_helper)
1642         helper.client = mock.MagicMock()
1643
1644         expected = helper.client.my_command()
1645         result = helper.execute('my_command')
1646         self.assertEqual(result, expected)
1647
1648         # TODO(elfoley): Make this a separate test: test_execute_no_client
1649         helper.client = object()
1650
1651         result = helper.execute('my_command')
1652         self.assertIsNone(result)
1653
1654
1655 class TestProxDataHelper(unittest.TestCase):
1656
1657     def test_totals_and_pps(self):
1658         pkt_size = 180
1659         vnfd_helper = mock.MagicMock()
1660         vnfd_helper.port_pairs.all_ports = list(range(4))
1661
1662         sut = mock.MagicMock()
1663         sut.multi_port_stats.return_value = (True,
1664                                              [[0, 1, 2, 3, 4, 5], [1, 1, 2, 3, 4, 5],
1665                                               [2, 1, 2, 3, 4, 5], [3, 1, 2, 3, 4, 5]])
1666
1667         data_helper = prox_helpers.ProxDataHelper(
1668             vnfd_helper, sut, pkt_size, 25, None,
1669             constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1670
1671         self.assertEqual(data_helper.rx_total, 4)
1672         self.assertEqual(data_helper.tx_total, 8)
1673         self.assertEqual(data_helper.requested_pps, 6250000.0)
1674
1675         vnfd_helper = mock.MagicMock()
1676         vnfd_helper.port_pairs.all_ports = [3, 4]
1677
1678         sut = mock.MagicMock()
1679         sut.multi_port_stats.return_value = (True,
1680                                              [[3, 1, 2, 3, 4, 5], [4, 1, 2, 3, 4, 5]])
1681
1682         data_helper = prox_helpers.ProxDataHelper(
1683             vnfd_helper, sut, pkt_size, 25, None,
1684             constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1685
1686         self.assertEqual(data_helper.rx_total, 2)
1687         self.assertEqual(data_helper.tx_total, 4)
1688         self.assertEqual(data_helper.requested_pps, 3125000.0)
1689
1690         vnfd_helper = mock.MagicMock()
1691         vnfd_helper.port_pairs.all_ports = [0, 1, 2, 3, 4, 6, 7]
1692
1693         sut = mock.MagicMock()
1694         sut.multi_port_stats.return_value = (True,
1695                                              [[8, 1, 2, 3, 4, 5], [9, 1, 2, 3, 4, 5]])
1696
1697         data_helper = prox_helpers.ProxDataHelper(
1698             vnfd_helper, sut, pkt_size, 25, None,
1699             constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1700
1701         self.assertEqual(data_helper.rx_total, 2)
1702         self.assertEqual(data_helper.tx_total, 4)
1703         self.assertEqual(data_helper.requested_pps, 10937500.0)
1704
1705         vnfd_helper = mock.MagicMock()
1706         vnfd_helper.port_pairs.all_ports = []
1707
1708         sut = mock.MagicMock()
1709         sut.multi_port_stats.return_value = (True,
1710                                              [[8, 1, 2, 3, 4, 5], [9, 1, 2, 3, 4, 5]])
1711
1712         data_helper = prox_helpers.ProxDataHelper(
1713             vnfd_helper, sut, pkt_size, 25, None,
1714             constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1715
1716         self.assertEqual(data_helper.rx_total, 2)
1717         self.assertEqual(data_helper.tx_total, 4)
1718         self.assertEqual(data_helper.requested_pps, 0.0)
1719
1720     def test_totals_and_pps2(self):
1721         pkt_size = 180
1722         vnfd_helper = mock.MagicMock()
1723         vnfd_helper.port_pairs.all_ports = list(range(4))
1724
1725         sut = mock.MagicMock()
1726         sut.multi_port_stats.return_value = (True,
1727                                              [[0, 'A', 2, 3, 4, 5], [1, 'B', 'C', 3, 4, 5],
1728                                               ['D', 1, 2, 3, 4, 5], [3, 1, 2, 3, 4, 'F']])
1729
1730         data_helper = prox_helpers.ProxDataHelper(
1731             vnfd_helper, sut, pkt_size, 25, None,
1732             constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1733
1734         self.assertEqual(data_helper.rx_total, 0)
1735         self.assertEqual(data_helper.tx_total, 0)
1736         self.assertEqual(data_helper.requested_pps, 0)
1737
1738     def test_samples(self):
1739         vnfd_helper = mock.MagicMock()
1740         vnfd_helper.ports_iter.return_value = [('xe0', 0), ('xe1', 1)]
1741
1742         sut = mock.MagicMock()
1743         sut.multi_port_stats.return_value = (True, [[0, 1, 2, 3, 4, 5], [1, 11, 12, 3, 4, 5]])
1744
1745         data_helper = prox_helpers.ProxDataHelper(
1746             vnfd_helper, sut, None, None, None, None)
1747
1748         expected = {
1749             'xe0': {
1750                 'in_packets': 1,
1751                 'out_packets': 2,
1752             },
1753             'xe1': {
1754                 'in_packets': 11,
1755                 'out_packets': 12,
1756             },
1757         }
1758         result = data_helper.samples
1759         self.assertDictEqual(result, expected)
1760
1761     def test_samples2(self):
1762         vnfd_helper = mock.MagicMock()
1763         vnfd_helper.ports_iter.return_value = [('xe1', 3), ('xe2', 7)]
1764
1765         sut = mock.MagicMock()
1766         sut.multi_port_stats.return_value = (True, [[3, 1, 2, 3, 4, 5], [7, 11, 12, 3, 4, 5]])
1767
1768         data_helper = prox_helpers.ProxDataHelper(
1769             vnfd_helper, sut, None, None, None, None)
1770
1771         expected = {
1772             'xe1': {
1773                 'in_packets': 1,
1774                 'out_packets': 2,
1775             },
1776             'xe2': {
1777                 'in_packets': 11,
1778                 'out_packets': 12,
1779             },
1780         }
1781         result = data_helper.samples
1782         self.assertDictEqual(result, expected)
1783
1784     def test___enter__(self):
1785         vnfd_helper = mock.MagicMock()
1786         vnfd_helper.port_pairs.all_ports = list(range(4))
1787         vnfd_helper.ports_iter.return_value = [('xe1', 3), ('xe2', 7)]
1788
1789         sut = mock.MagicMock()
1790
1791         data_helper = prox_helpers.ProxDataHelper(vnfd_helper, sut, None, None,
1792             5.4, constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
1793         data_helper._totals_and_pps = 12, 32, 4.5
1794         data_helper.tsc_hz = 9.8
1795         data_helper.measured_stats = {
1796             'delta': prox_helpers.TotStatsTuple(6.1, 6.2, 6.3, 6.4)}
1797         data_helper.latency = 7
1798
1799         self.assertIsNone(data_helper.result_tuple)
1800         self.assertEqual(data_helper.line_speed, 10000000000)
1801
1802         expected = prox_helpers.ProxTestDataTuple(
1803             5.4, 9.8, 6.1, 6.2, 6.3, 7, 12, 32, 4.5)
1804         with data_helper:
1805             pass
1806
1807         result = data_helper.result_tuple
1808         self.assertEqual(result, expected)
1809
1810         data_helper.make_tuple()
1811         self.assertIs(data_helper.result_tuple, result)
1812
1813     def test___enter___negative(self):
1814         vnfd_helper = mock.MagicMock()
1815
1816         data_helper = prox_helpers.ProxDataHelper(
1817             vnfd_helper, None, None, None, None, None)
1818
1819         vnfd_helper.port_pairs.all_ports = []
1820         with self.assertRaises(AssertionError):
1821             with data_helper:
1822                 pass
1823
1824         vnfd_helper.port_pairs.all_ports = [0, 1, 2]
1825         with self.assertRaises(AssertionError):
1826             with data_helper:
1827                 pass
1828
1829     def test_measure_tot_stats(self):
1830         vnfd_helper = mock.MagicMock()
1831         vnfd_helper.port_pairs.all_ports = list(range(4))
1832
1833         start = (3, 4, 1, 2)
1834         end = (9, 7, 6, 8)
1835
1836         sut = prox_helpers.ProxSocketHelper(mock.MagicMock())
1837         sut.get_all_tot_stats = mock.MagicMock(side_effect=[start, end])
1838
1839         data_helper = prox_helpers.ProxDataHelper(
1840             vnfd_helper, sut, None, None, 5.4, None)
1841
1842         self.assertIsNone(data_helper.measured_stats)
1843
1844         expected = {
1845             'start_tot': start,
1846             'end_tot': end,
1847             'delta': prox_helpers.TotStatsTuple(6, 3, 5, 6),
1848         }
1849         with data_helper.measure_tot_stats():
1850             pass
1851
1852         self.assertEqual(data_helper.measured_stats, expected)
1853
1854     def test_capture_tsc_hz(self):
1855         vnfd_helper = mock.MagicMock()
1856         vnfd_helper.port_pairs.all_ports = list(range(4))
1857
1858         sut = mock.MagicMock()
1859         sut.hz.return_value = '54.6'
1860
1861         data_helper = prox_helpers.ProxDataHelper(
1862             vnfd_helper, sut, None, None, None, None)
1863
1864         self.assertIsNone(data_helper.tsc_hz)
1865
1866         expected = 54.6
1867         data_helper.capture_tsc_hz()
1868         self.assertEqual(data_helper.tsc_hz, expected)
1869
1870
1871 class TestProxProfileHelper(unittest.TestCase):
1872
1873     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.utils')
1874     def test_get_cls(self, mock_utils):
1875         mock_type1 = mock.MagicMock()
1876         mock_type1.__prox_profile_type__ = 'another_type'
1877         mock_type2 = mock.MagicMock()
1878         mock_type2.__prox_profile_type__ = 'my_type'
1879         mock_utils.itersubclasses.return_value = [mock_type1, mock_type2]
1880
1881         self.assertEqual(prox_helpers.ProxProfileHelper.get_cls('my_type'),
1882                          mock_type2)
1883
1884     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.utils')
1885     def test_get_cls_default(self, mock_utils):
1886         mock_utils.itersubclasses.return_value = []
1887         prox_helpers.ProxProfileHelper.get_cls('my_type')
1888
1889     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.SocketTopology')
1890     def test_cpu_topology(self, mock_socket_topology):
1891         mock_socket_topology.parse_cpuinfo.return_value = 432
1892
1893         resource_helper = mock.MagicMock()
1894         resource_helper.setup_helper.ssh_helper.execute.return_value = 0, 'output', ''
1895
1896         helper = prox_helpers.ProxProfileHelper(resource_helper)
1897         self.assertIsNone(helper._cpu_topology)
1898         result = helper.cpu_topology
1899         self.assertEqual(result, 432)
1900         self.assertIs(result, helper._cpu_topology)
1901         self.assertIs(result, helper.cpu_topology)
1902
1903     # TODO(elfoley): Split this test; there are two sets of inputs/outputs
1904     def test_test_cores(self):
1905         resource_helper = mock.MagicMock()
1906         resource_helper.setup_helper.prox_config_data = []
1907
1908         helper = prox_helpers.ProxProfileHelper(resource_helper)
1909         helper._cpu_topology = []
1910
1911         expected = []
1912         result = helper.test_cores
1913         self.assertEqual(result, expected)
1914
1915         resource_helper.setup_helper.prox_config_data = [
1916             ('section1', []),
1917             ('section2', [
1918                 ('a', 'b'),
1919                 ('c', 'd'),
1920             ]),
1921             ('core 1s3', []),
1922             ('core 2s5', [
1923                 ('index', 8),
1924                 ('mode', ''),
1925             ]),
1926             ('core 3s1', [
1927                 ('index', 5),
1928                 ('mode', 'gen'),
1929             ]),
1930             ('core 4s9h', [
1931                 ('index', 7),
1932                 ('mode', 'gen'),
1933             ]),
1934         ]
1935
1936         helper = prox_helpers.ProxProfileHelper(resource_helper)
1937         helper._cpu_topology = {
1938             1: {
1939                 3: {
1940                     'key1': (23, 32),
1941                     'key2': (12, 21),
1942                     'key3': (44, 33),
1943                 },
1944             },
1945             9: {
1946                 4: {
1947                     'key1': (44, 32),
1948                     'key2': (23, 21),
1949                     'key3': (12, 33),
1950                 },
1951             },
1952         }
1953
1954         self.assertIsNone(helper._test_cores)
1955         expected = [3, 4]
1956         result = helper.test_cores
1957         self.assertEqual(result, expected)
1958         self.assertIs(result, helper._test_cores)
1959         self.assertIs(result, helper.test_cores)
1960
1961     # TODO(elfoley): Split this test; there are two sets of inputs/outputs
1962     def test_latency_cores(self):
1963         resource_helper = mock.MagicMock()
1964         resource_helper.setup_helper.prox_config_data = []
1965
1966         helper = prox_helpers.ProxProfileHelper(resource_helper)
1967         helper._cpu_topology = []
1968
1969         expected = []
1970         result = helper.latency_cores
1971         self.assertEqual(result, expected)
1972
1973         resource_helper.setup_helper.prox_config_data = [
1974             ('section1', []),
1975             ('section2', [
1976                 ('a', 'b'),
1977                 ('c', 'd'),
1978             ]),
1979             ('core 1s3', []),
1980             ('core 2s5', [
1981                 ('index', 8),
1982                 ('mode', ''),
1983             ]),
1984             ('core 3s1', [
1985                 ('index', 5),
1986                 ('mode', 'lat'),
1987             ]),
1988             ('core 4s9h', [
1989                 ('index', 7),
1990                 ('mode', 'lat'),
1991             ]),
1992         ]
1993
1994         helper = prox_helpers.ProxProfileHelper(resource_helper)
1995         helper._cpu_topology = {
1996             1: {
1997                 3: {
1998                     'key1': (23, 32),
1999                     'key2': (12, 21),
2000                     'key3': (44, 33),
2001                 },
2002             },
2003             9: {
2004                 4: {
2005                     'key1': (44, 32),
2006                     'key2': (23, 21),
2007                     'key3': (12, 33),
2008                 },
2009             },
2010         }
2011
2012         self.assertIsNone(helper._latency_cores)
2013         expected = [3, 4]
2014         result = helper.latency_cores
2015         self.assertEqual(result, expected)
2016         self.assertIs(result, helper._latency_cores)
2017         self.assertIs(result, helper.latency_cores)
2018
2019     def test_all_rx_cores(self):
2020         helper = prox_helpers.ProxBngProfileHelper(mock.MagicMock())
2021         helper._latency_cores = expected = [3, 4, 6]
2022         helper._test_cores = [5, 2, 1]
2023
2024         result = helper.all_rx_cores
2025         self.assertEqual(result, expected)
2026
2027     def test_get_cores(self):
2028         resource_helper = mock.MagicMock()
2029         resource_helper.setup_helper.prox_config_data = [
2030             ('section1', []),
2031             ('section2', [
2032                 ('a', 'b'),
2033                 ('c', 'd'),
2034             ]),
2035             ('core 1', []),
2036             ('core 2', [
2037                 ('index', 8),
2038                 ('mode', ''),
2039             ]),
2040             ('core 3', [
2041                 ('index', 5),
2042                 ('mode', 'gen'),
2043             ]),
2044             ('core 4', [
2045                 ('index', 7),
2046                 ('mode', 'gen'),
2047             ]),
2048         ]
2049
2050         helper = prox_helpers.ProxProfileHelper(resource_helper)
2051         helper._cpu_topology = {
2052             0: {
2053                 1: {
2054                     5: (5, 1, 0)
2055                 },
2056                 2: {
2057                     6: (6, 2, 0)
2058                 },
2059                 3: {
2060                     7: (7, 3, 0)
2061                 },
2062                 4: {
2063                     8: (8, 3, 0)
2064                 },
2065             }
2066         }
2067
2068         expected = [3, 4]
2069         result = helper.get_cores(helper.PROX_CORE_GEN_MODE)
2070         self.assertEqual(result, expected)
2071
2072     def test_get_latency(self):
2073         resource_helper = mock.MagicMock()
2074         resource_helper.setup_helper.vnfd_helper.interfaces = []
2075
2076         helper = prox_helpers.ProxProfileHelper(resource_helper)
2077         helper._latency_cores = []
2078
2079         expected = []
2080         result = helper.get_latency()
2081         self.assertEqual(result, expected)
2082
2083         helper._latency_cores = [1, 2]
2084         helper.client = mock.MagicMock()
2085
2086         expected = helper.sut.lat_stats()
2087         result = helper.get_latency()
2088         self.assertIs(result, expected)
2089
2090     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
2091     def test_traffic_context(self, *args):
2092         setup_helper = mock.MagicMock()
2093         setup_helper.vnfd_helper.interfaces = []
2094
2095         helper = prox_helpers.ProxProfileHelper(setup_helper)
2096         helper._cpu_topology = {
2097             0: {
2098                 1: {
2099                     5: (5, 1, 0)
2100                 },
2101                 2: {
2102                     6: (6, 2, 0)
2103                 },
2104                 3: {
2105                     7: (7, 3, 0)
2106                 },
2107                 4: {
2108                     8: (8, 3, 0)
2109                 },
2110             }
2111         }
2112
2113         setup_helper.prox_config_data = [
2114             ('global', [
2115                 ('not_name', 'other data'),
2116                 ('name_not', 'more data'),
2117                 ('name', helper.__prox_profile_type__),
2118             ]),
2119             ('section1', []),
2120             ('section2', [
2121                 ('a', 'b'),
2122                 ('c', 'd'),
2123             ]),
2124             ('core 1', []),
2125             ('core 2', [
2126                 ('index', 8),
2127                 ('mode', ''),
2128             ]),
2129             ('core 3', [
2130                 ('index', 5),
2131                 ('mode', 'gen'),
2132                 ('name', 'tagged'),
2133             ]),
2134             ('core 4', [
2135                 ('index', 7),
2136                 ('mode', 'gen'),
2137                 ('name', 'udp'),
2138             ]),
2139         ]
2140
2141         client = mock.MagicMock()
2142         client.hz.return_value = 2
2143
2144         helper.client = client
2145         helper.get_latency = mock.MagicMock(return_value=[3.3, 3.6, 3.8])
2146
2147         helper._test_cores = [3, 4]
2148
2149         with helper.traffic_context(64, 1):
2150             pass
2151
2152     def test_run_test(self, *args):
2153         resource_helper = mock.MagicMock()
2154         resource_helper.step_delta = 0.4
2155         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2156         resource_helper.sut.multi_port_stats.return_value = (True, [[0, 1, 1, 2, 4, 5],
2157                                                                     [1, 1, 2, 3, 4, 5]])
2158
2159         helper = prox_helpers.ProxProfileHelper(resource_helper)
2160
2161         helper.run_test(pkt_size=120, duration=5, value=6.5, tolerated_loss=0.0,
2162                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2163         self.assertTrue(resource_helper.sut.multi_port_stats.called)
2164         self.assertTrue(resource_helper.sut.stop_all.called)
2165         self.assertTrue(resource_helper.sut.reset_stats.called)
2166
2167 class TestProxMplsProfileHelper(unittest.TestCase):
2168
2169     def test_mpls_cores(self):
2170         resource_helper = mock.MagicMock()
2171         resource_helper.setup_helper.prox_config_data = [
2172             ('section1', []),
2173             ('section2', [
2174                 ('a', 'b'),
2175                 ('c', 'd'),
2176             ]),
2177             ('core 1', []),
2178             ('core 2', [
2179                 ('index', 8),
2180                 ('mode', ''),
2181             ]),
2182             ('core 3', [
2183                 ('index', 5),
2184                 ('mode', 'gen'),
2185                 ('name', 'tagged'),
2186             ]),
2187             ('core 4', [
2188                 ('index', 7),
2189                 ('mode', 'gen'),
2190                 ('name', 'udp'),
2191             ]),
2192         ]
2193
2194         helper = prox_helpers.ProxMplsProfileHelper(resource_helper)
2195         helper._cpu_topology = {
2196             0: {
2197                 1: {
2198                     5: (5, 1, 0)
2199                 },
2200                 2: {
2201                     6: (6, 2, 0)
2202                 },
2203                 3: {
2204                     7: (7, 3, 0)
2205                 },
2206                 4: {
2207                     8: (8, 3, 0)
2208                 },
2209             }
2210         }
2211
2212         expected_tagged = [3]
2213         expected_plain = [4]
2214         self.assertIsNone(helper._cores_tuple)
2215         self.assertEqual(helper.tagged_cores, expected_tagged)
2216         self.assertEqual(helper.plain_cores, expected_plain)
2217         self.assertEqual(helper._cores_tuple, (expected_tagged, expected_plain))
2218
2219     def test_traffic_context(self):
2220         setup_helper = mock.MagicMock()
2221         helper = prox_helpers.ProxMplsProfileHelper(setup_helper)
2222
2223         with helper.traffic_context(120, 5.4):
2224             pass
2225
2226
2227 class TestProxBngProfileHelper(unittest.TestCase):
2228
2229     def test_bng_cores(self):
2230         resource_helper = mock.MagicMock()
2231         resource_helper.setup_helper.prox_config_data = [
2232             ('section1', []),
2233             ('section2', [
2234                 ('a', 'b'),
2235                 ('c', 'd'),
2236             ]),
2237             ('core 1', []),
2238             ('core 2', [
2239                 ('index', 8),
2240                 ('mode', ''),
2241             ]),
2242             ('core 3', [
2243                 ('index', 5),
2244                 ('mode', 'gen'),
2245                 ('name', 'cpe'),
2246             ]),
2247             ('core 4', [
2248                 ('index', 7),
2249                 ('mode', 'gen'),
2250                 ('name', 'inet'),
2251             ]),
2252             ('core 6', [
2253                 ('index', 3),
2254                 ('mode', 'gen'),
2255                 ('name', 'arp_task'),
2256             ]),
2257             ('core 9', [
2258                 ('index', 2),
2259                 ('mode', 'gen'),
2260                 ('name', 'arp'),
2261             ]),
2262         ]
2263
2264         helper = prox_helpers.ProxBngProfileHelper(resource_helper)
2265         helper._cpu_topology = {
2266             0: {
2267                 1: {
2268                     5: (5, 1, 0)
2269                 },
2270                 2: {
2271                     6: (6, 2, 0)
2272                 },
2273                 3: {
2274                     7: (7, 3, 0)
2275                 },
2276                 4: {
2277                     8: (8, 3, 0)
2278                 },
2279                 6: {
2280                     1: (4, 8, 0)
2281                 },
2282                 9: {
2283                     2: (3, 7, 0)
2284                 },
2285             }
2286         }
2287
2288         expected_cpe = [3]
2289         expected_inet = [4]
2290         expected_arp = [6, 9]
2291         expected_arp_task = [0, 6]
2292         expected_combined = (expected_cpe, expected_inet, expected_arp, expected_arp_task)
2293
2294         self.assertIsNone(helper._cores_tuple)
2295         self.assertEqual(helper.cpe_cores, expected_cpe)
2296         self.assertEqual(helper.inet_cores, expected_inet)
2297         self.assertEqual(helper.arp_cores, expected_arp)
2298         self.assertEqual(helper.arp_task_cores, expected_arp_task)
2299         self.assertEqual(helper._cores_tuple, expected_combined)
2300
2301     def test_run_test(self, *args):
2302         resource_helper = mock.MagicMock()
2303         resource_helper.step_delta = 0.4
2304         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2305         resource_helper.sut.multi_port_stats.return_value = (True, [[0, 1, 1, 2, 4, 5],
2306                                                                     [1, 1, 2, 3, 4, 5]])
2307
2308         helper = prox_helpers.ProxBngProfileHelper(resource_helper)
2309
2310         helper.run_test(pkt_size=120, duration=5, value=6.5, tolerated_loss=0.0,
2311                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2312         self.assertTrue(resource_helper.sut.multi_port_stats.called)
2313         self.assertTrue(resource_helper.sut.stop_all.called)
2314         self.assertTrue(resource_helper.sut.reset_stats.called)
2315
2316         resource_helper.reset_mock()
2317
2318         # negative pkt_size is the only way to make ratio > 1
2319         helper.run_test(pkt_size=-1000, duration=5, value=6.5, tolerated_loss=0.0,
2320                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2321
2322         self.assertTrue(resource_helper.sut.multi_port_stats.called)
2323         self.assertTrue(resource_helper.sut.stop_all.called)
2324         self.assertTrue(resource_helper.sut.reset_stats.called)
2325
2326 class TestProxVpeProfileHelper(unittest.TestCase):
2327
2328     def test_vpe_cores(self):
2329         resource_helper = mock.MagicMock()
2330         resource_helper.setup_helper.prox_config_data = [
2331             ('section1', []),
2332             ('section2', [
2333                 ('a', 'b'),
2334                 ('c', 'd'),
2335             ]),
2336             ('core 1', []),
2337             ('core 2', [
2338                 ('index', 8),
2339                 ('mode', ''),
2340             ]),
2341             ('core 3', [
2342                 ('index', 5),
2343                 ('mode', 'gen'),
2344                 ('name', 'cpe'),
2345             ]),
2346             ('core 4', [
2347                 ('index', 7),
2348                 ('mode', 'gen'),
2349                 ('name', 'inet'),
2350             ]),
2351         ]
2352
2353         helper = prox_helpers.ProxVpeProfileHelper(resource_helper)
2354         helper._cpu_topology = {
2355             0: {
2356                 1: {
2357                     5: (5, 1, 0)
2358                 },
2359                 2: {
2360                     6: (6, 2, 0)
2361                 },
2362                 3: {
2363                     7: (7, 3, 0)
2364                 },
2365                 4: {
2366                     8: (8, 3, 0)
2367                 },
2368             }
2369         }
2370
2371         expected_cpe = [3]
2372         expected_inet = [4]
2373         expected_combined = (expected_cpe, expected_inet)
2374
2375         self.assertIsNone(helper._cores_tuple)
2376         self.assertEqual(helper.cpe_cores, expected_cpe)
2377         self.assertEqual(helper.inet_cores, expected_inet)
2378         self.assertEqual(helper._cores_tuple, expected_combined)
2379
2380     def test_vpe_ports(self):
2381         resource_helper = mock.MagicMock()
2382         resource_helper.setup_helper.prox_config_data = [
2383             ('section1', []),
2384             ('section2', [
2385                 ('a', 'b'),
2386                 ('c', 'd'),
2387             ]),
2388             ('port 3', [
2389                 ('index', '5'),
2390                 ('name', 'cpe'),
2391                 ('mac', 'hardware'),
2392             ]),
2393             ('port 4', [
2394                 ('index', '7'),
2395                 ('name', 'inet'),
2396                 ('mac', 'hardware'),
2397             ]),
2398         ]
2399
2400         helper = prox_helpers.ProxVpeProfileHelper(resource_helper)
2401         helper._port_list = {
2402             0: {
2403                 1: {
2404                     5: 'cpe'
2405                 },
2406                 2: {
2407                     6: 'inet'
2408                 },
2409                 3: {
2410                     7: 'cpe'
2411                 },
2412                 4: {
2413                     8: 'inet'
2414                 },
2415             }
2416         }
2417
2418         expected_cpe = [3]
2419         expected_inet = [4]
2420         expected_combined = (expected_cpe, expected_inet)
2421
2422         self.assertIsNone(helper._ports_tuple)
2423         self.assertEqual(helper.cpe_ports, expected_cpe)
2424         self.assertEqual(helper.inet_ports, expected_inet)
2425         self.assertEqual(helper._ports_tuple, expected_combined)
2426
2427     def test_run_test(self, *args):
2428         resource_helper = mock.MagicMock()
2429         resource_helper.step_delta = 0.4
2430         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2431         resource_helper.sut.multi_port_stats.return_value = (True, [[0, 1, 1, 2, 4, 5],
2432                                                                     [1, 1, 2, 3, 4, 5]])
2433
2434         helper = prox_helpers.ProxVpeProfileHelper(resource_helper)
2435
2436         helper.run_test(pkt_size=120, duration=5, value=6.5, tolerated_loss=0.0,
2437                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2438
2439         # negative pkt_size is the only way to make ratio > 1
2440         helper.run_test(pkt_size=-1000, duration=5, value=6.5, tolerated_loss=0.0,
2441                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2442
2443 class TestProxlwAFTRProfileHelper(unittest.TestCase):
2444
2445     def test_lwaftr_cores(self):
2446         resource_helper = mock.MagicMock()
2447         resource_helper.setup_helper.prox_config_data = [
2448             ('section1', []),
2449             ('section2', [
2450                 ('a', 'b'),
2451                 ('c', 'd'),
2452             ]),
2453             ('core 1', []),
2454             ('core 2', [
2455                 ('index', 8),
2456                 ('mode', ''),
2457             ]),
2458             ('core 3', [
2459                 ('index', 5),
2460                 ('mode', 'gen'),
2461                 ('name', 'tun'),
2462             ]),
2463             ('core 4', [
2464                 ('index', 7),
2465                 ('mode', 'gen'),
2466                 ('name', 'inet'),
2467             ]),
2468         ]
2469
2470         helper = prox_helpers.ProxlwAFTRProfileHelper(resource_helper)
2471         helper._cpu_topology = {
2472             0: {
2473                 1: {
2474                     5: (5, 1, 0)
2475                 },
2476                 2: {
2477                     6: (6, 2, 0)
2478                 },
2479                 3: {
2480                     7: (7, 3, 0)
2481                 },
2482                 4: {
2483                     8: (8, 3, 0)
2484                 },
2485             }
2486         }
2487
2488         expected_tun = [3]
2489         expected_inet = [4]
2490         expected_combined = (expected_tun, expected_inet)
2491
2492         self.assertIsNone(helper._cores_tuple)
2493         self.assertEqual(helper.tun_cores, expected_tun)
2494         self.assertEqual(helper.inet_cores, expected_inet)
2495         self.assertEqual(helper._cores_tuple, expected_combined)
2496
2497     def test_tun_ports(self):
2498         resource_helper = mock.MagicMock()
2499         resource_helper.setup_helper.prox_config_data = [
2500             ('section1', []),
2501             ('section2', [
2502                 ('a', 'b'),
2503                 ('c', 'd'),
2504             ]),
2505             ('port 3', [
2506                 ('index', '5'),
2507                 ('name', 'lwB4'),
2508                 ('mac', 'hardware'),
2509             ]),
2510             ('port 4', [
2511                 ('index', '7'),
2512                 ('name', 'inet'),
2513                 ('mac', 'hardware'),
2514             ]),
2515         ]
2516
2517         helper = prox_helpers.ProxlwAFTRProfileHelper(resource_helper)
2518         helper._port_list = {
2519             0: {
2520                 1: {
2521                     5: 'lwB4'
2522                 },
2523                 2: {
2524                     6: 'inet'
2525                 },
2526                 3: {
2527                     7: 'lwB4'
2528                 },
2529                 4: {
2530                     8: 'inet'
2531                 },
2532             }
2533         }
2534
2535         expected_tun = [3]
2536         expected_inet = [4]
2537         expected_combined = (expected_tun, expected_inet)
2538
2539         self.assertIsNone(helper._ports_tuple)
2540         self.assertEqual(helper.tun_ports, expected_tun)
2541         self.assertEqual(helper.inet_ports, expected_inet)
2542         self.assertEqual(helper._ports_tuple, expected_combined)
2543
2544     def test_run_test(self, *args):
2545         resource_helper = mock.MagicMock()
2546         resource_helper.step_delta = 0.4
2547         resource_helper.vnfd_helper.port_pairs.all_ports = list(range(2))
2548         resource_helper.sut.multi_port_stats.return_value = (True, [[0, 1, 2, 4, 6, 5],
2549                                                                     [1, 1, 2, 3, 4, 5]])
2550
2551         helper = prox_helpers.ProxlwAFTRProfileHelper(resource_helper)
2552
2553         helper.run_test(pkt_size=120, duration=5, value=6.5, tolerated_loss=0.0,
2554                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)
2555
2556         # negative pkt_size is the only way to make ratio > 1
2557         helper.run_test(pkt_size=-1000, duration=5, value=6.5, tolerated_loss=0.0,
2558                         line_speed=constants.NIC_GBPS_DEFAULT * constants.ONE_GIGABIT_IN_BITS)