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