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

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