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