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

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