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 from contextlib import contextmanager
  25 import mock
  26
  27 from tests.unit import STL_MOCKS
  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 ProxResourceHelper
  42
  43
  44 class TestCoreTuple(unittest.TestCase):
  45     def test___init__(self):
  46         core_tuple = CoreSocketTuple('core 5s6')
  47         self.assertEqual(core_tuple.core_id, 5)
  48         self.assertEqual(core_tuple.socket_id, 6)
  49         self.assertFalse(core_tuple.is_hyperthread())
  50
  51         core_tuple = CoreSocketTuple('core 5s6h')
  52         self.assertEqual(core_tuple.core_id, 5)
  53         self.assertEqual(core_tuple.socket_id, 6)
  54         self.assertTrue(core_tuple.is_hyperthread())
  55
  56     def test___init__negative(self):
  57         bad_inputs = [
  58             '',
  59             '5',
  60             '5s',
  61             '6h',
  62             '5s6',
  63             'core',
  64             'core h',
  65             'core 5s',
  66             'core 5 6',
  67             'core 5 6h',
  68             'core 5d6',
  69             'core 5d6h',
  70             1,
  71             2.3,
  72             [],
  73             {},
  74             object(),
  75         ]
  76
  77         for bad_input in bad_inputs:
  78             with self.assertRaises(ValueError):
  79                 CoreSocketTuple(bad_input)
  80
  81     def test_find_in_topology(self):
  82         topology_in = {
  83             6: {
  84                 5: {
  85                     'key1': ['a', 'b'],
  86                     'key2': ['c', 'd'],
  87                 },
  88             },
  89         }
  90
  91         core_tuple = CoreSocketTuple('core 5s6')
  92
  93         expected = 'a'
  94         result = core_tuple.find_in_topology(topology_in)
  95         self.assertEqual(result, expected)
  96
  97         core_tuple = CoreSocketTuple('core 5s6h')
  98
  99         expected = 'c'
 100         result = core_tuple.find_in_topology(topology_in)
 101         self.assertEqual(result, expected)
 102
 103     def test_find_in_topology_negative(self):
 104         core_tuple = CoreSocketTuple('core 6s5')
 105         with self.assertRaises(ValueError):
 106             # no socket key
 107             core_tuple.find_in_topology({})
 108
 109         with self.assertRaises(ValueError):
 110             # no core key
 111             core_tuple.find_in_topology({5: {}})
 112
 113         with self.assertRaises(ValueError):
 114             # no first value (as needed by non-hyperthread core)
 115             core_tuple.find_in_topology({5: {6: {'key1': []}}})
 116
 117         core_tuple = CoreSocketTuple('core 6s5h')
 118         with self.assertRaises(ValueError):
 119             # no second value (as needed by hyperthread core)
 120             core_tuple.find_in_topology({5: {6: {'key1': ['e']}}})
 121
 122
 123 class TestTotStatsTuple(unittest.TestCase):
 124     def test___new___negative(self):
 125         with self.assertRaises(TypeError):
 126             # no values
 127             TotStatsTuple()
 128
 129         with self.assertRaises(TypeError):
 130             # one, non-integer value
 131             TotStatsTuple('a')
 132
 133         with self.assertRaises(TypeError):
 134             # too many values
 135             TotStatsTuple(3, 4, 5, 6, 7)
 136
 137
 138 class TestProxTestDataTuple(unittest.TestCase):
 139     def test___init__(self):
 140         prox_test_data = ProxTestDataTuple(1, 2, 3, 4, 5, 6, 7, 8, 9)
 141         self.assertEqual(prox_test_data.tolerated, 1)
 142         self.assertEqual(prox_test_data.tsc_hz, 2)
 143         self.assertEqual(prox_test_data.delta_rx, 3)
 144         self.assertEqual(prox_test_data.delta_tx, 4)
 145         self.assertEqual(prox_test_data.delta_tsc, 5)
 146         self.assertEqual(prox_test_data.latency, 6)
 147         self.assertEqual(prox_test_data.rx_total, 7)
 148         self.assertEqual(prox_test_data.tx_total, 8)
 149         self.assertEqual(prox_test_data.pps, 9)
 150
 151     def test_properties(self):
 152         prox_test_data = ProxTestDataTuple(1, 2, 3, 4, 5, 6, 7, 8, 9)
 153         self.assertEqual(prox_test_data.pkt_loss, 12.5)
 154         self.assertEqual(prox_test_data.mpps, 1.6 / 1e6)
 155         self.assertEqual(prox_test_data.can_be_lost, 0)
 156         self.assertEqual(prox_test_data.drop_total, 1)
 157         self.assertFalse(prox_test_data.success)
 158
 159         prox_test_data = ProxTestDataTuple(10, 2, 3, 4, 5, 6, 997, 998, 9)
 160         self.assertTrue(prox_test_data.success)
 161
 162     def test_pkt_loss_zero_division(self):
 163         prox_test_data = ProxTestDataTuple(1, 2, 3, 4, 5, 6, 7, 0, 9)
 164         self.assertEqual(prox_test_data.pkt_loss, 100.0)
 165
 166     def test_get_samples(self):
 167         prox_test_data = ProxTestDataTuple(1, 2, 3, 4, 5, [6.1, 6.9, 6.4], 7, 8, 9)
 168
 169         expected = {
 170             "Throughput": 1.6 / 1e6,
 171             "DropPackets": 12.5,
 172             "CurrentDropPackets": 12.5,
 173             "TxThroughput": 9 / 1e6,
 174             "RxThroughput": 1.6 / 1e6,
 175             "PktSize": 64,
 176             "PortSample": 1,
 177             "LatencyMin": 6.1,
 178             "LatencyMax": 6.9,
 179             "LatencyAvg": 6.4,
 180         }
 181         result = prox_test_data.get_samples(64, port_samples={"PortSample": 1})
 182         self.assertDictEqual(result, expected)
 183
 184         expected = {
 185             "Throughput": 1.6 / 1e6,
 186             "DropPackets": 0.123,
 187             "CurrentDropPackets": 0.123,
 188             "TxThroughput": 9 / 1e6,
 189             "RxThroughput": 1.6 / 1e6,
 190             "PktSize": 64,
 191             "LatencyMin": 6.1,
 192             "LatencyMax": 6.9,
 193             "LatencyAvg": 6.4,
 194         }
 195         result = prox_test_data.get_samples(64, 0.123)
 196         self.assertDictEqual(result, expected)
 197
 198     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.LOG')
 199     def test_log_data(self, mock_logger):
 200         my_mock_logger = mock.MagicMock()
 201         prox_test_data = ProxTestDataTuple(1, 2, 3, 4, 5, [6.1, 6.9, 6.4], 7, 8, 9)
 202         prox_test_data.log_data()
 203         self.assertEqual(my_mock_logger.debug.call_count, 0)
 204         self.assertEqual(mock_logger.debug.call_count, 2)
 205
 206         mock_logger.debug.reset_mock()
 207         prox_test_data.log_data(my_mock_logger)
 208         self.assertEqual(my_mock_logger.debug.call_count, 2)
 209         self.assertEqual(mock_logger.debug.call_count, 0)
 210
 211
 212 class TestPacketDump(unittest.TestCase):
 213     PAYLOAD = "payload"
 214
 215     def test__init__(self):
 216         PacketDump("port_id", len(self.PAYLOAD), self.PAYLOAD)
 217
 218     def test___str__(self):
 219         expected = '<PacketDump port: port_id payload: {}>'.format(self.PAYLOAD)
 220         dump1 = PacketDump("port_id", len(self.PAYLOAD), self.PAYLOAD)
 221         self.assertEqual(str(dump1), expected)
 222
 223     def test_port_id(self):
 224         p = PacketDump("port_id", len(self.PAYLOAD), self.PAYLOAD)
 225         self.assertEqual(p.port_id, "port_id")
 226
 227     def test_data_len(self):
 228         p = PacketDump("port_id", len(self.PAYLOAD), self.PAYLOAD)
 229         self.assertEqual(p.data_len, len(self.PAYLOAD))
 230
 231     def test_payload(self):
 232         p = PacketDump("port_id", len(self.PAYLOAD), self.PAYLOAD)
 233         self.assertEqual(p.payload(), self.PAYLOAD)
 234
 235         self.assertEqual(p.payload(3), self.PAYLOAD[3:])
 236
 237         self.assertEqual(p.payload(end=3), self.PAYLOAD[:4])
 238
 239         self.assertEqual(p.payload(2, 4), self.PAYLOAD[2:5])
 240
 241
 242 PACKET_DUMP_1 = """\
 243 pktdump,3,11
 244 hello world
 245 """
 246
 247 PACKET_DUMP_2 = """\
 248 pktdump,3,11
 249 hello world
 250 pktdump,2,9
 251 brown fox jumped over
 252 pktdump,4,8
 253 lazy
 254 dog
 255 """
 256
 257 PACKET_DUMP_NON_1 = """\
 258 not_a_dump,1,2
 259 other data
 260 """
 261
 262 PACKET_DUMP_MIXED_1 = """\
 263 pktdump,3,11
 264 hello world
 265 not_a_dump,1,2
 266 other data
 267 """
 268
 269 PACKET_DUMP_BAD_1 = """\
 270 pktdump,one,12
 271 bad port id
 272 """
 273
 274 PACKET_DUMP_BAD_2 = """\
 275 pktdump,3,twelve
 276 bad data length
 277 """
 278
 279 PACKET_DUMP_BAD_3 = """\
 280 pktdump,3
 281 no data length value
 282 """
 283
 284
 285 @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
 286 class TestProxSocketHelper(unittest.TestCase):
 287     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.socket')
 288     def test___init__(self, mock_socket, mock_time):
 289         expected = mock_socket.socket()
 290         prox = ProxSocketHelper()
 291         result = prox._sock
 292         self.assertEqual(result, expected)
 293
 294     def test_connect(self, mock_time):
 295         mock_sock = mock.MagicMock()
 296         prox = ProxSocketHelper(mock_sock)
 297         prox.connect('10.20.30.40', 23456)
 298         self.assertEqual(mock_sock.connect.call_count, 1)
 299
 300     def test_get_sock(self, mock_time):
 301         mock_sock = mock.MagicMock()
 302         prox = ProxSocketHelper(mock_sock)
 303         result = prox.get_socket()
 304         self.assertIs(result, mock_sock)
 305
 306     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.select')
 307     def test_get_data(self, mock_select, mock_time):
 308         mock_select.select.side_effect = [[1], [0]]
 309         mock_socket = mock.MagicMock()
 310         mock_recv = mock_socket.recv()
 311         mock_recv.decode.return_value = ""
 312         prox = ProxSocketHelper(mock_socket)
 313         ret = prox.get_data()
 314         self.assertEqual(ret, "")
 315         self.assertEqual(len(prox._pkt_dumps), 0)
 316
 317         mock_select.select.reset_mock()
 318         mock_select.select.side_effect = chain([['a'], ['']], repeat([1], 3))
 319         mock_recv.decode.return_value = PACKET_DUMP_1
 320         ret = prox.get_data()
 321         self.assertEqual(mock_select.select.call_count, 2)
 322         self.assertEqual(ret, 'pktdump,3,11')
 323         self.assertEqual(len(prox._pkt_dumps), 1)
 324
 325         mock_select.select.reset_mock()
 326         mock_select.select.side_effect = chain([[object()], [None]], repeat([1], 3))
 327         mock_recv.decode.return_value = PACKET_DUMP_2
 328         ret = prox.get_data()
 329         self.assertEqual(mock_select.select.call_count, 2)
 330         self.assertEqual(ret, 'jumped over')
 331         self.assertEqual(len(prox._pkt_dumps), 3)
 332
 333     def test__parse_socket_data_mixed_data(self, mock_time):
 334         prox = ProxSocketHelper(mock.MagicMock())
 335         ret = prox._parse_socket_data(PACKET_DUMP_NON_1, False)
 336         self.assertEqual(ret, 'not_a_dump,1,2')
 337         self.assertEqual(len(prox._pkt_dumps), 0)
 338
 339         ret = prox._parse_socket_data(PACKET_DUMP_MIXED_1, False)
 340         self.assertEqual(ret, 'not_a_dump,1,2')
 341         self.assertEqual(len(prox._pkt_dumps), 1)
 342
 343     def test__parse_socket_data_bad_data(self, mock_time):
 344         prox = ProxSocketHelper(mock.MagicMock())
 345         with self.assertRaises(ValueError):
 346             prox._parse_socket_data(PACKET_DUMP_BAD_1, False)
 347
 348         with self.assertRaises(ValueError):
 349             prox._parse_socket_data(PACKET_DUMP_BAD_2, False)
 350
 351         ret = prox._parse_socket_data(PACKET_DUMP_BAD_3, False)
 352         self.assertEqual(ret, 'pktdump,3')
 353
 354     def test__parse_socket_data_pkt_dump_only(self, mock_time):
 355         prox = ProxSocketHelper(mock.MagicMock())
 356         ret = prox._parse_socket_data('', True)
 357         self.assertFalse(ret)
 358
 359         ret = prox._parse_socket_data(PACKET_DUMP_1, True)
 360         self.assertTrue(ret)
 361
 362         ret = prox._parse_socket_data(PACKET_DUMP_2, True)
 363         self.assertTrue(ret)
 364
 365     def test_put_command(self, mock_time):
 366         mock_socket = mock.MagicMock()
 367         prox = ProxSocketHelper(mock_socket)
 368         prox.put_command("data")
 369         mock_socket.sendall.assert_called_once()
 370
 371     def test_put_command_socket_error(self, mock_time):
 372         mock_socket = mock.MagicMock()
 373         mock_socket.sendall.side_effect = OSError
 374         prox = ProxSocketHelper(mock_socket)
 375         prox.put_command("data")
 376         mock_socket.sendall.assert_called_once()
 377
 378     def test_get_packet_dump(self, mock_time):
 379         mock_socket = mock.MagicMock()
 380         prox = ProxSocketHelper(mock_socket)
 381         prox._pkt_dumps = []
 382         self.assertIsNone(prox.get_packet_dump())
 383
 384         prox._pkt_dumps = [234]
 385         self.assertEqual(prox.get_packet_dump(), 234)
 386         self.assertEqual(prox._pkt_dumps, [])
 387
 388     def test_stop_all_reset(self, mock_time):
 389         mock_socket = mock.MagicMock()
 390         prox = ProxSocketHelper(mock_socket)
 391         prox.stop_all_reset()
 392         mock_socket.sendall.assert_called()
 393
 394     def test_stop_all(self, mock_time):
 395         mock_socket = mock.MagicMock()
 396         prox = ProxSocketHelper(mock_socket)
 397         prox.stop_all()
 398         mock_socket.sendall.assert_called()
 399
 400     def test_stop(self, mock_time):
 401         mock_socket = mock.MagicMock()
 402         prox = ProxSocketHelper(mock_socket)
 403         prox.stop([3, 4, 5], 16)
 404         mock_socket.sendall.assert_called()
 405
 406     def test_start_all(self, mock_time):
 407         mock_socket = mock.MagicMock()
 408         prox = ProxSocketHelper(mock_socket)
 409         prox.start_all()
 410         mock_socket.sendall.assert_called()
 411
 412     def test_start(self, mock_time):
 413         mock_socket = mock.MagicMock()
 414         prox = ProxSocketHelper(mock_socket)
 415         prox.start([3, 4, 5])
 416         mock_socket.sendall.assert_called()
 417
 418     def test_reset_stats(self, mock_time):
 419         mock_socket = mock.MagicMock()
 420         prox = ProxSocketHelper(mock_socket)
 421         prox.reset_stats()
 422         mock_socket.sendall.assert_called()
 423
 424     def test_set_pkt_size(self, mock_time):
 425         mock_socket = mock.MagicMock()
 426         prox = ProxSocketHelper(mock_socket)
 427         prox.set_pkt_size([3, 4, 5], 1024)
 428         self.assertEqual(mock_socket.sendall.call_count, 3)
 429
 430     def test_set_value(self, mock_time):
 431         mock_socket = mock.MagicMock()
 432         prox = ProxSocketHelper(mock_socket)
 433         prox.set_value([3, 4, 5], 10, 20, 30)
 434         self.assertEqual(mock_socket.sendall.call_count, 3)
 435
 436     def test_reset_values(self, mock_time):
 437         mock_socket = mock.MagicMock()
 438         prox = ProxSocketHelper(mock_socket)
 439         prox.reset_values([3, 4, 5])
 440         self.assertEqual(mock_socket.sendall.call_count, 3)
 441
 442     def test_set_speed(self, mock_time):
 443         mock_socket = mock.MagicMock()
 444         prox = ProxSocketHelper(mock_socket)
 445         prox.set_speed([3, 4, 5], 1000)
 446         self.assertEqual(mock_socket.sendall.call_count, 3)
 447
 448     def test_slope_speed(self, mock_time):
 449         core_data = [
 450             {
 451                 'cores': [3, 4, 5],
 452                 'speed': 1000,
 453             },
 454             {
 455                 'cores': [9, 10, 11],
 456                 'speed': '500.5',
 457             },
 458         ]
 459
 460         mock_socket = mock.MagicMock()
 461         prox = ProxSocketHelper(mock_socket)
 462         prox.set_speed = set_speed = mock.MagicMock()
 463         prox.slope_speed(core_data, 5)
 464         self.assertEqual(set_speed.call_count, 20)
 465
 466         set_speed.reset_mock()
 467         prox.slope_speed(core_data, 5, 5)
 468         self.assertEqual(set_speed.call_count, 10)
 469
 470     def test_set_pps(self, mock_time):
 471         mock_socket = mock.MagicMock()
 472         prox = ProxSocketHelper(mock_socket)
 473         prox.set_pps([3, 4, 5], 1000, 512)
 474         self.assertEqual(mock_socket.sendall.call_count, 3)
 475
 476     def test_lat_stats(self, mock_time):
 477         latency_output = [
 478             '1, 2 , 3',  # has white space
 479             '4,5',  # too short
 480             '7,8,9,10.5,11',  # too long with float, but float is in unused portion
 481             'twelve,13,14',  # value as English word
 482             '15,16.2,17',  # float in used portion
 483         ]
 484
 485         mock_socket = mock.MagicMock()
 486         prox = ProxSocketHelper(mock_socket)
 487         prox.get_data = mock.MagicMock(side_effect=latency_output)
 488
 489         expected = (
 490             {
 491                 3: 1,
 492                 5: 7,
 493             },
 494             {
 495                 3: 2,
 496                 5: 8,
 497             },
 498             {
 499                 3: 3,
 500                 5: 9,
 501             },
 502         )
 503         result = prox.lat_stats([3, 4, 5, 6, 7], 16)
 504         self.assertEqual(mock_socket.sendall.call_count, 5)
 505         self.assertEqual(result, expected)
 506
 507     def test_get_all_tot_stats_error(self, mock_time):
 508         mock_socket = mock.MagicMock()
 509         prox = ProxSocketHelper(mock_socket)
 510         prox.get_data = mock.MagicMock(return_value='3,4,5')
 511         expected = [0, 0, 0, 0]
 512         result = prox.get_all_tot_stats()
 513         self.assertEqual(result, expected)
 514
 515     def test_get_all_tot_stats(self, mock_time):
 516         mock_socket = mock.MagicMock()
 517         prox = ProxSocketHelper(mock_socket)
 518         prox.get_data = mock.MagicMock(return_value='3,4,5,6')
 519         expected = 3, 4, 5, 6
 520         result = prox.get_all_tot_stats()
 521         self.assertEqual(result, expected)
 522
 523     def test_hz(self, mock_time):
 524         mock_socket = mock.MagicMock()
 525         prox = ProxSocketHelper(mock_socket)
 526         prox.get_data = mock.MagicMock(return_value='3,4,5,6')
 527         expected = 6
 528         result = prox.hz()
 529         self.assertEqual(result, expected)
 530
 531     def test_rx_stats(self, mock_time):
 532         core_stats = [
 533             '3,4,5,6',
 534             '7,8,9,10,NaN',
 535             '11,12,13,14,15',
 536         ]
 537
 538         mock_socket = mock.MagicMock()
 539         prox = ProxSocketHelper(mock_socket)
 540         prox.get_data = mock.MagicMock(side_effect=core_stats)
 541         expected = 21, 24, 27, 14
 542         result = prox.rx_stats([3, 4, 5], 16)
 543         self.assertEqual(result, expected)
 544
 545     def test_core_stats(self, mock_time):
 546         core_stats = [
 547             '3,4,5,6',
 548             '7,8,9,10,NaN',
 549             '11,12,13,14,15',
 550         ]
 551
 552         mock_socket = mock.MagicMock()
 553         prox = ProxSocketHelper(mock_socket)
 554         prox.get_data = mock.MagicMock(side_effect=core_stats)
 555         expected = 21, 24, 27, 14
 556         result = prox.core_stats([3, 4, 5], 16)
 557         self.assertEqual(result, expected)
 558
 559     def test_port_stats(self, mock_time):
 560         port_stats = [
 561             ','.join(str(n) for n in range(3, 15)),
 562             ','.join(str(n) for n in range(8, 32, 2)),
 563             ','.join(str(n) for n in range(5, 89, 7)),
 564         ]
 565
 566         mock_socket = mock.MagicMock()
 567         prox = ProxSocketHelper(mock_socket)
 568         prox.get_data = mock.MagicMock(side_effect=port_stats)
 569         expected = [16, 26, 36, 46, 56, 66, 76, 86, 96, 106, 116, 126]
 570         result = prox.port_stats([3, 4, 5])
 571         self.assertEqual(result, expected)
 572
 573     def test_measure_tot_stats(self, mock_time):
 574         start_tot = 3, 4, 5, 6
 575         end_tot = 7, 9, 11, 13
 576         delta_tot = 4, 5, 6, 7
 577
 578         get_data_output = [
 579             ','.join(str(n) for n in start_tot),
 580             ','.join(str(n) for n in end_tot),
 581         ]
 582
 583         mock_socket = mock.MagicMock()
 584         prox = ProxSocketHelper(mock_socket)
 585         prox.get_data = mock.MagicMock(side_effect=get_data_output)
 586         expected = {
 587             'start_tot': start_tot,
 588             'end_tot': end_tot,
 589             'delta': delta_tot,
 590         }
 591         with prox.measure_tot_stats() as result:
 592             pass
 593         self.assertEqual(result, expected)
 594
 595     def test_tot_stats(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, 4, 5
 600         result = prox.tot_stats()
 601         self.assertEqual(result, expected)
 602
 603     def test_tot_ierrors(self, mock_time):
 604         mock_socket = mock.MagicMock()
 605         prox = ProxSocketHelper(mock_socket)
 606         prox.get_data = mock.MagicMock(return_value='3,4,5,6')
 607         expected = 3, 3
 608         result = prox.tot_ierrors()
 609         self.assertEqual(result, expected)
 610
 611     def test_set_count(self, mock_time):
 612         mock_socket = mock.MagicMock()
 613         prox = ProxSocketHelper(mock_socket)
 614         prox.set_count(432, [3, 4, 5])
 615         self.assertEqual(mock_socket.sendall.call_count, 3)
 616
 617     def test_dump_rx(self, mock_time):
 618         mock_socket = mock.MagicMock()
 619         prox = ProxSocketHelper(mock_socket)
 620         prox.dump_rx(3, 5, 8)
 621         self.assertEqual(mock_socket.sendall.call_count, 1)
 622
 623     def test_quit(self, mock_time):
 624         mock_socket = mock.MagicMock()
 625         prox = ProxSocketHelper(mock_socket)
 626         prox.quit()
 627         mock_socket.sendall.assert_called()
 628
 629     def test_force_quit(self, mock_time):
 630         mock_socket = mock.MagicMock()
 631         prox = ProxSocketHelper(mock_socket)
 632         prox.force_quit()
 633         mock_socket.sendall.assert_called()
 634
 635
 636 class TestProxDpdkVnfSetupEnvHelper(unittest.TestCase):
 637     def test__replace_quoted_with_value(self):
 638         # empty string
 639         input_str = ''
 640         expected = ''
 641         result = ProxDpdkVnfSetupEnvHelper._replace_quoted_with_value(input_str, 'cat')
 642         self.assertEqual(result, expected)
 643
 644         # no quoted substring
 645         input_str = 'lion tiger bear'
 646         expected = 'lion tiger bear'
 647         result = ProxDpdkVnfSetupEnvHelper._replace_quoted_with_value(input_str, 'cat')
 648         self.assertEqual(result, expected)
 649
 650         # partially quoted substring
 651         input_str = 'lion "tiger bear'
 652         expected = 'lion "tiger bear'
 653         result = ProxDpdkVnfSetupEnvHelper._replace_quoted_with_value(input_str, 'cat')
 654         self.assertEqual(result, expected)
 655
 656         # one quoted substring
 657         input_str = 'lion "tiger" bear'
 658         expected = 'lion "cat" bear'
 659         result = ProxDpdkVnfSetupEnvHelper._replace_quoted_with_value(input_str, 'cat')
 660         self.assertEqual(result, expected)
 661
 662         # two quoted substrings
 663         input_str = 'lion "tiger" bear "shark" whale'
 664         expected = 'lion "cat" bear "shark" whale'
 665         result = ProxDpdkVnfSetupEnvHelper._replace_quoted_with_value(input_str, 'cat')
 666         self.assertEqual(result, expected)
 667
 668         # two quoted substrings, both replaced
 669         input_str = 'lion "tiger" bear "shark" whale'
 670         expected = 'lion "cat" bear "cat" whale'
 671         result = ProxDpdkVnfSetupEnvHelper._replace_quoted_with_value(input_str, 'cat', 2)
 672         self.assertEqual(result, expected)
 673
 674     def test__get_tx_port(self):
 675         # no data
 676         input_data = {'section1': []}
 677         expected = -1
 678         result = ProxDpdkVnfSetupEnvHelper._get_tx_port('section1', input_data)
 679         self.assertEqual(result, expected)
 680
 681         # data for other section
 682         input_data = {
 683             'section1': [],
 684             'section2': [
 685                 ('rx port', '3'),
 686                 ('tx port', '4'),
 687             ],
 688         }
 689         expected = -1
 690         result = ProxDpdkVnfSetupEnvHelper._get_tx_port('section1', input_data)
 691         self.assertEqual(result, expected)
 692
 693         # data for section
 694         input_data['section1'] = section1 = [
 695             ('rx port', '4', 'more', 432),
 696             ('tx port', '3'),
 697         ]
 698         expected = 3
 699         result = ProxDpdkVnfSetupEnvHelper._get_tx_port('section1', input_data)
 700         self.assertEqual(result, expected)
 701
 702         # more data for section,
 703         section1.extend([
 704             ('rx port', '2'),
 705             ('tx port', '1', 'and more', 234),
 706         ])
 707         expected = 1
 708         result = ProxDpdkVnfSetupEnvHelper._get_tx_port('section1', input_data)
 709         self.assertEqual(result, expected)
 710
 711     def test_write_prox_config(self):
 712         input_data = {}
 713         expected = ''
 714         result = ProxDpdkVnfSetupEnvHelper.write_prox_config(input_data)
 715         self.assertEqual(result, expected)
 716
 717         input_data = [
 718             [
 719                 'section1',
 720                 [],
 721             ],
 722         ]
 723         expected = '[section1]'
 724         result = ProxDpdkVnfSetupEnvHelper.write_prox_config(input_data)
 725         self.assertEqual(result, expected)
 726
 727         input_data = [
 728             [
 729                 'section1',
 730                 [],
 731             ],
 732             [
 733                 'section2',
 734                 [
 735                     ['key1', 'value1'],
 736                     ['__name__', 'not this one'],
 737                     ['key2', None],
 738                     ['key3', 234],
 739                     ['key4', 'multi-line\nvalue'],
 740                 ],
 741             ],
 742         ]
 743         expected = os.linesep.join([
 744             '[section1]',
 745             '[section2]',
 746             'key1=value1',
 747             'key2',
 748             'key3=234',
 749             'key4=multi-line\n\tvalue',
 750         ])
 751         result = ProxDpdkVnfSetupEnvHelper.write_prox_config(input_data)
 752         self.assertEqual(result, expected)
 753
 754     def test_rebind_drivers(self):
 755         def find_drivers(*args, **kwargs):
 756             setup_helper.used_drivers = used_drivers
 757
 758         used_drivers = {
 759             'a': (1, 'b'),
 760             'c': (2, 'd'),
 761         }
 762
 763         vnfd_helper = mock.MagicMock()
 764         ssh_helper = mock.MagicMock()
 765         scenario_helper = mock.MagicMock()
 766         setup_helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
 767         setup_helper._find_used_drivers = mock_find = mock.MagicMock(side_effect=find_drivers)
 768
 769         setup_helper.rebind_drivers()
 770         self.assertEqual(mock_find.call_count, 1)
 771         self.assertEqual(ssh_helper.execute.call_count, 2)
 772         self.assertIn('--force', ssh_helper.execute.call_args[0][0])
 773
 774         mock_find.reset_mock()
 775         ssh_helper.execute.reset_mock()
 776         setup_helper.rebind_drivers(False)
 777         self.assertEqual(mock_find.call_count, 0)
 778         self.assertEqual(ssh_helper.execute.call_count, 2)
 779         self.assertNotIn('--force', ssh_helper.execute.call_args[0][0])
 780
 781     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.find_relative_file')
 782     def test_build_config_file_no_additional_file(self, mock_find_path):
 783         vnf1 = {
 784             'prox_args': {'-c': ""},
 785             'prox_path': 'd',
 786             'prox_config': 'e/f',
 787         }
 788
 789         mock_find_path.side_effect = ['1', '2']
 790
 791         vnfd_helper = mock.MagicMock()
 792         ssh_helper = mock.MagicMock()
 793         scenario_helper = ScenarioHelper('vnf1')
 794         scenario_helper.scenario_cfg = {
 795             'task_path': 'a/b',
 796             'options': {
 797                 'vnf1': vnf1,
 798             },
 799         }
 800
 801         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
 802         helper.copy_to_target = mock.MagicMock(return_value='3')
 803         helper.generate_prox_config_file = mock.MagicMock(return_value='4')
 804         helper.upload_prox_config = mock.MagicMock(return_value='5')
 805
 806         self.assertEqual(helper.additional_files, {})
 807         self.assertNotEqual(helper.prox_config_dict, '4')
 808         self.assertNotEqual(helper.remote_path, '5')
 809         helper.build_config_file()
 810         self.assertEqual(helper.additional_files, {})
 811         self.assertEqual(helper.prox_config_dict, '4')
 812         self.assertEqual(helper.remote_path, '5')
 813
 814     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.find_relative_file')
 815     def test_build_config_file_additional_file_string(self, mock_find_path):
 816         vnf1 = {
 817             'prox_args': {'-c': ""},
 818             'prox_path': 'd',
 819             'prox_config': 'e/f',
 820             'prox_files': 'g/h.i',
 821         }
 822
 823         mock_find_path.side_effect = ['1', '2']
 824         vnfd_helper = mock.MagicMock()
 825         ssh_helper = mock.MagicMock()
 826         scenario_helper = ScenarioHelper('vnf1')
 827         scenario_helper.scenario_cfg = {
 828             'task_path': 'a/b',
 829             'options': {
 830                 'vnf1': vnf1,
 831             },
 832         }
 833
 834         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
 835         helper.copy_to_target = mock.MagicMock(side_effect=['33', '34', '35'])
 836         helper.generate_prox_config_file = mock.MagicMock(return_value='44')
 837         helper.upload_prox_config = mock.MagicMock(return_value='55')
 838
 839         self.assertEqual(helper.additional_files, {})
 840         expected = {'h.i': '33'}
 841         helper.build_config_file()
 842         self.assertDictEqual(helper.additional_files, expected)
 843
 844     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.find_relative_file')
 845     def test_build_config_file_additional_file(self, mock_find_path):
 846         vnf1 = {
 847             'prox_args': {'-c': ""},
 848             'prox_path': 'd',
 849             'prox_config': 'e/f',
 850             'prox_files': [
 851                 'g/h.i',
 852                 'j/k/l',
 853                 'm_n',
 854             ],
 855         }
 856
 857         mock_find_path.side_effect = ['1', '2']
 858         vnfd_helper = mock.MagicMock()
 859         ssh_helper = mock.MagicMock()
 860         scenario_helper = ScenarioHelper('vnf1')
 861         scenario_helper.scenario_cfg = {
 862             'task_path': 'a/b',
 863             'options': {
 864                 'vnf1': vnf1,
 865             },
 866         }
 867
 868         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
 869         helper.copy_to_target = mock.MagicMock(side_effect=['33', '34', '35'])
 870         helper.generate_prox_config_file = mock.MagicMock(return_value='44')
 871         helper.upload_prox_config = mock.MagicMock(return_value='55')
 872
 873         self.assertEqual(helper.additional_files, {})
 874         self.assertNotEqual(helper.prox_config_dict, '44')
 875         self.assertNotEqual(helper.remote_path, '55')
 876         expected = {'h.i': '33', 'l': '34', 'm_n': '35'}
 877         helper.build_config_file()
 878         self.assertDictEqual(helper.additional_files, expected)
 879         self.assertEqual(helper.prox_config_dict, '44')
 880         self.assertEqual(helper.remote_path, '55')
 881
 882     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.find_relative_file')
 883     def test_build_config(self, mock_find_path):
 884         vnf1 = {
 885             'prox_args': {'-f': ""},
 886             'prox_path': '/opt/nsb_bin/prox',
 887             'prox_config': 'configs/gen_l2fwd-2.cfg',
 888             'prox_files': [
 889                 'g/h.i',
 890                 'j/k/l',
 891                 'm_n',
 892             ],
 893         }
 894
 895         mock_find_path.side_effect = ['1', '2']
 896         vnfd_helper = mock.MagicMock()
 897         ssh_helper = mock.MagicMock()
 898         ssh_helper.provision_tool.return_value = "/opt/nsb_bin/prox"
 899         scenario_helper = ScenarioHelper('vnf1')
 900         scenario_helper.scenario_cfg = {
 901             'task_path': 'a/b',
 902             'options': {
 903                 'vnf1': vnf1,
 904             },
 905         }
 906
 907         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
 908         helper.remote_path = "/tmp/prox.cfg"
 909         prox_cmd = helper.build_config()
 910         expected = "sudo bash -c 'cd /opt/nsb_bin; /opt/nsb_bin/prox -o cli -f  -f /tmp/prox.cfg '"
 911         self.assertEqual(prox_cmd, expected)
 912
 913     def test__insert_additional_file(self):
 914         vnfd_helper = mock.MagicMock()
 915         ssh_helper = mock.MagicMock()
 916         scenario_helper = mock.MagicMock()
 917
 918         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
 919         helper.additional_files = {"ipv4.lua": "/tmp/ipv4.lua"}
 920         res = helper._insert_additional_file('dofile("ipv4.lua")')
 921         self.assertEqual(res, 'dofile("/tmp/ipv4.lua")')
 922
 923     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ConfigParser')
 924     def test_generate_prox_config_file(self, mock_parser_type):
 925         def init(*args):
 926             if sections_data:
 927                 args[-1].extend(sections_data)
 928             return mock.MagicMock()
 929
 930         sections_data = []
 931
 932         mock_parser_type.side_effect = init
 933
 934         vnfd_helper = mock.MagicMock()
 935         vnfd_helper.interfaces = []
 936         ssh_helper = mock.MagicMock()
 937         scenario_helper = mock.MagicMock()
 938
 939         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
 940         helper.additional_files = {}
 941
 942         expected = []
 943         result = helper.generate_prox_config_file('a/b')
 944         self.assertEqual(result, expected)
 945
 946         helper.additional_files = {"ipv4.lua": "/tmp/ipv4.lua"}
 947
 948         helper.remote_prox_file_name = 'remote'
 949         vnfd_helper.interfaces = [
 950             {
 951                 'virtual-interface': {
 952                     'dst_mac': '00:00:00:de:ad:88',
 953                 },
 954             },
 955             {
 956                 'virtual-interface': {
 957                     'dst_mac': '00:00:00:de:ad:ee',
 958                 },
 959             },
 960             {
 961                 'virtual-interface': {
 962                     'dst_mac': '00:00:00:de:ad:ff',
 963                 },
 964             },
 965         ]
 966         sections_data = [
 967             [
 968                 'lua',
 969                 [
 970                     ['dofile("ipv4.lua")', ''],
 971                 ],
 972             ],
 973             [
 974                 'port 0',
 975                 [
 976                     ['ip', ''],
 977                     ['mac', 'foo'],
 978                     ['dst mac', '@@2'],
 979                     ['tx port', '1'],
 980                 ],
 981             ],
 982             [
 983                 'port 2',
 984                 [
 985                     ['ip', ''],
 986                     ['$sut_mac0', '@@dst_mac0'],
 987                     ['tx port', '0'],
 988                     ['single', '@'],
 989                     ['user_table', 'dofile("ipv4.lua")'],
 990                     ['missing_addtional_file', 'dofile("nosuch")'],
 991                 ],
 992             ],
 993         ]
 994
 995         expected = [
 996             [
 997                 'lua',
 998                 [
 999                     ['dofile("/tmp/ipv4.lua")', ''],
1000                 ],
1001             ],
1002             [
1003                 'port 0',
1004                 [
1005                     ['ip', ''],
1006                     ['mac', 'hardware'],
1007                     ['dst mac', '00:00:00:de:ad:ff'],
1008                     ['tx port', '1'],
1009                 ],
1010             ],
1011             [
1012                 'port 2',
1013                 [
1014                     ['ip', ''],
1015                     ['$sut_mac0', '00 00 00 de ad 88'],
1016                     ['tx port', '0'],
1017                     ['single', '@'],
1018                     ['user_table', 'dofile("/tmp/ipv4.lua")'],
1019                     ['missing_addtional_file', 'dofile("nosuch")'],
1020                 ],
1021             ],
1022         ]
1023         result = helper.generate_prox_config_file('/c/d/e')
1024         self.assertEqual(result, expected, str(result))
1025
1026     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ConfigParser')
1027     def test_generate_prox_config_file_negative(self, mock_parser_type):
1028         def init(*args):
1029             args[-1].update(sections_data)
1030             return mock.MagicMock()
1031
1032         sections_data = {}
1033
1034         mock_parser_type.side_effect = init
1035
1036         vnfd_helper = mock.MagicMock()
1037         vnfd_helper.interfaces = []
1038         ssh_helper = mock.MagicMock()
1039         scenario_helper = mock.MagicMock()
1040
1041         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1042         helper.additional_files = {}
1043         helper.remote_prox_file_name = 'remote'
1044         vnfd_helper.interfaces = [
1045             {
1046                 'virtual-interface': {
1047                     'dpdk_port_num': 3,
1048                     'dst_mac': '00:00:00:de:ad:88',
1049                 },
1050             },
1051             {
1052                 'virtual-interface': {
1053                     'dpdk_port_num': 5,
1054                     'dst_mac': '00:00:00:de:ad:ff',
1055                 },
1056             },
1057             {
1058                 'virtual-interface': {
1059                     'dpdk_port_num': 7,
1060                     'dst_mac': '00:00:00:de:ad:ff',
1061                 },
1062             },
1063         ]
1064         sections_data = {
1065             'port 3': [
1066                 ['ip', ''],
1067                 ['mac', 'foo'],
1068                 ['dst mac', ''],
1069             ],
1070             'port 5': [
1071                 ['ip', ''],
1072                 ['dst mac', ''],
1073                 ['tx port', '0'],
1074                 ['???', 'dofile "here" 23'],
1075             ],
1076         }
1077
1078         with self.assertRaises(Exception):
1079             helper.generate_prox_config_file('a/b')
1080
1081     def test_generate_prox_lua_file(self):
1082         vnfd_helper = mock.MagicMock()
1083         vnfd_helper.interfaces = []
1084         ssh_helper = mock.MagicMock()
1085         scenario_helper = mock.MagicMock()
1086
1087         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1088         helper.LUA_PARAMETER_NAME = 'sut'
1089
1090         expected = ''
1091         result = helper.generate_prox_lua_file()
1092         self.assertEqual(result, expected)
1093
1094         vnfd_helper.interfaces = [
1095             {
1096                 'local_ip': '10.20.30.40',
1097                 'dst_ip': '10.11.12.13',
1098                 'virtual-interface': {
1099                     'dpdk_port_num': 3,
1100                 },
1101             },
1102             {
1103                 'local_ip': '10.20.30.45',
1104                 'dst_ip': '10.11.12.19',
1105                 'virtual-interface': {
1106                     'dpdk_port_num': 7,
1107                 },
1108             },
1109         ]
1110
1111         expected = os.linesep.join([
1112             'sut_hex_ip_port_3:"0a 14 1e 28"',
1113             'sut_ip_port_3:"10.20.30.40"',
1114             'gen_hex_ip_port_3:"0a 0b 0c 0d"',
1115             'gen_ip_port_3:"10.11.12.13"',
1116
1117             'sut_hex_ip_port_7:"0a 14 1e 2d"',
1118             'sut_ip_port_7:"10.20.30.45"',
1119             'gen_hex_ip_port_7:"0a 0b 0c 13"',
1120             'gen_ip_port_7:"10.11.12.19"',
1121         ])
1122         result = helper.generate_prox_lua_file()
1123         self.assertEqual(result, expected)
1124
1125     def test_upload_prox_lua(self):
1126         def identity(*args):
1127             return args
1128
1129         vnfd_helper = mock.MagicMock()
1130         vnfd_helper.interfaces = []
1131         ssh_helper = mock.MagicMock()
1132         scenario_helper = mock.MagicMock()
1133
1134         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1135         helper.generate_prox_lua_file = mock.MagicMock(return_value=234)
1136         helper.put_string_to_file = identity
1137
1138         expected = ''
1139         result = helper.upload_prox_lua('my_dir', {})
1140         self.assertEqual(result, expected)
1141
1142         input_data = {
1143             'lua': {
1144                 'key1': 'value1 ("inside") tail',
1145                 'key2': 'value2',
1146                 'key3 ("key_side") head': 'value3',
1147             },
1148         }
1149
1150         expected = 234, 'my_dir/key_side'
1151         result = helper.upload_prox_lua('my_dir', input_data)
1152         self.assertEqual(result, expected)
1153
1154     def test_put_string_to_file(self):
1155         vnfd_helper = mock.MagicMock()
1156         vnfd_helper.interfaces = []
1157         ssh_helper = mock.MagicMock()
1158         scenario_helper = mock.MagicMock()
1159
1160         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1161
1162         expected = 'a/b'
1163         result = helper.put_string_to_file('my long string', 'a/b')
1164         self.assertEqual(result, expected)
1165
1166     def test__build_pipeline_kwarags(self):
1167         vnfd_helper = mock.MagicMock()
1168         ssh_helper = mock.MagicMock()
1169         ssh_helper.provision_tool.return_value = "/tmp/nosuch"
1170         scenario_helper = mock.MagicMock()
1171
1172         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1173         helper._build_pipeline_kwargs()
1174         self.assertEqual(helper.pipeline_kwargs, {'tool_path': '/tmp/nosuch', 'tool_dir': '/tmp'})
1175
1176     def test_copy_to_target(self):
1177         vnfd_helper = mock.MagicMock()
1178         vnfd_helper.interfaces = []
1179         ssh_helper = mock.MagicMock()
1180         scenario_helper = mock.MagicMock()
1181
1182         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1183         expected = '/tmp/c'
1184         result = helper.copy_to_target('a/b', 'c')
1185         self.assertEqual(result, expected)
1186
1187     def test_upload_prox_config(self):
1188         vnfd_helper = mock.MagicMock()
1189         vnfd_helper.interfaces = []
1190         ssh_helper = mock.MagicMock()
1191         scenario_helper = mock.MagicMock()
1192
1193         helper = ProxDpdkVnfSetupEnvHelper(vnfd_helper, ssh_helper, scenario_helper)
1194         helper.write_prox_config = mock.MagicMock(return_value='a long string')
1195         expected = '/tmp/a'
1196         result = helper.upload_prox_config('a', {})
1197         self.assertEqual(result, expected)
1198
1199
1200 class TestProxResourceHelper(unittest.TestCase):
1201     def test_line_rate_to_pps(self):
1202         expected = 0.25 * 1e8
1203         result = ProxResourceHelper.line_rate_to_pps(180, 4)
1204         self.assertEqual(result, expected)
1205
1206     def test_find_pci(self):
1207         input_str_list = [
1208             'no target here',
1209             'nor here',
1210             'and still not',
1211         ]
1212         result = ProxResourceHelper.find_pci('target', input_str_list)
1213         self.assertFalse(result)
1214
1215         input_str_list = [
1216             'no target here',
1217             'nor here',
1218             'this is a target',
1219             'did we miss it',
1220         ]
1221         result = ProxResourceHelper.find_pci('target', input_str_list)
1222         self.assertTrue(result)
1223
1224     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.RETRY_INTERVAL', 0)
1225     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ProxSocketHelper')
1226     def test_sut(self, mock_socket_helper):
1227         helper = ProxResourceHelper(mock.MagicMock())
1228         self.assertIsNone(helper.client)
1229         result = helper.sut
1230         self.assertIsNotNone(result)
1231         self.assertIs(result, helper.client)
1232         self.assertIs(result, helper.sut)
1233
1234     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.SocketTopology')
1235     def test_cpu_topology(self, mock_socket_topology):
1236         mock_socket_topology.parse_cpuinfo.return_value = 432
1237
1238         setup_helper = mock.MagicMock()
1239         setup_helper.ssh_helper.execute.return_value = 0, 'output', ''
1240
1241         helper = ProxResourceHelper(setup_helper)
1242         self.assertIsNone(helper._cpu_topology)
1243         result = helper.cpu_topology
1244         self.assertEqual(result, 432)
1245         self.assertIs(result, helper._cpu_topology)
1246         self.assertIs(result, helper.cpu_topology)
1247
1248     def test_test_cores(self):
1249         setup_helper = mock.MagicMock()
1250         setup_helper.prox_config_dict = {}
1251
1252         helper = ProxResourceHelper(setup_helper)
1253         helper._cpu_topology = []
1254
1255         expected = []
1256         result = helper.test_cores
1257         self.assertEqual(result, expected)
1258
1259         setup_helper.prox_config_dict = [
1260             ('section1', []),
1261             ('section2', [
1262                 ('a', 'b'),
1263                 ('c', 'd'),
1264             ]),
1265             ('core 1s3', []),
1266             ('core 2s5', [
1267                 ('index', 8),
1268                 ('mode', ''),
1269             ]),
1270             ('core 3s1', [
1271                 ('index', 5),
1272                 ('mode', 'gen'),
1273             ]),
1274             ('core 4s9h', [
1275                 ('index', 7),
1276                 ('mode', 'gen'),
1277             ]),
1278         ]
1279
1280         helper = ProxResourceHelper(setup_helper)
1281         helper._cpu_topology = {
1282             1: {
1283                 3: {
1284                     'key1': (23, 32),
1285                     'key2': (12, 21),
1286                     'key3': (44, 33),
1287                 },
1288             },
1289             9: {
1290                 4: {
1291                     'key1': (44, 32),
1292                     'key2': (23, 21),
1293                     'key3': (12, 33),
1294                 },
1295             },
1296         }
1297
1298         self.assertIsNone(helper._test_cores)
1299         expected = [12, 23]
1300         result = helper.test_cores
1301         self.assertEqual(result, expected)
1302         self.assertIs(result, helper._test_cores)
1303         self.assertIs(result, helper.test_cores)
1304
1305     def test_get_test_type(self):
1306         setup_helper = mock.MagicMock()
1307         setup_helper.prox_config_dict = {}
1308
1309         helper = ProxResourceHelper(setup_helper)
1310         setup_helper.prox_config_dict = [
1311             ('global', [
1312                 ('name', helper.PROX_CORE_MPLS_TEST)
1313             ]),
1314             ('section2', [
1315                 ('a', 'b'),
1316                 ('c', 'd'),
1317             ]),
1318             ('core 1', []),
1319             ('core 2', [
1320                 ('index', 8),
1321                 ('mode', ''),
1322             ]),
1323             ('core 3', [
1324                 ('index', 5),
1325                 ('mode', 'gen'),
1326             ]),
1327             ('core 4', [
1328                 ('index', 7),
1329                 ('mode', 'gen'),
1330             ]),
1331         ]
1332         test_type = helper.get_test_type()
1333         self.assertEqual(test_type, helper.PROX_CORE_MPLS_TEST)
1334
1335     def test_get_cores(self):
1336         setup_helper = mock.MagicMock()
1337         setup_helper.prox_config_dict = {}
1338
1339         helper = ProxResourceHelper(setup_helper)
1340         helper._cpu_topology = {
1341             0: {
1342                 1: {
1343                     5: (5, 1, 0)
1344                 },
1345                 2: {
1346                     6: (6, 2, 0)
1347                 },
1348                 3: {
1349                     7: (7, 3, 0)
1350                 },
1351                 4: {
1352                     8: (8, 3, 0)
1353                 },
1354             }
1355         }
1356
1357         setup_helper.prox_config_dict = [
1358             ('section1', []),
1359             ('section2', [
1360                 ('a', 'b'),
1361                 ('c', 'd'),
1362             ]),
1363             ('core 1', []),
1364             ('core 2', [
1365                 ('index', 8),
1366                 ('mode', ''),
1367             ]),
1368             ('core 3', [
1369                 ('index', 5),
1370                 ('mode', 'gen'),
1371             ]),
1372             ('core 4', [
1373                 ('index', 7),
1374                 ('mode', 'gen'),
1375             ]),
1376         ]
1377
1378         expected = [7, 8]
1379         result = helper.get_cores(helper.PROX_CORE_GEN_MODE)
1380         self.assertEqual(result, expected)
1381
1382     def test_get_cores_mpls(self):
1383         setup_helper = mock.MagicMock()
1384         setup_helper.prox_config_dict = {}
1385
1386         helper = ProxResourceHelper(setup_helper)
1387         helper._cpu_topology = {
1388             0: {
1389                 1: {
1390                     5: (5, 1, 0)
1391                 },
1392                 2: {
1393                     6: (6, 2, 0)
1394                 },
1395                 3: {
1396                     7: (7, 3, 0)
1397                 },
1398                 4: {
1399                     8: (8, 3, 0)
1400                 },
1401             }
1402         }
1403
1404         setup_helper.prox_config_dict = [
1405             ('section1', []),
1406             ('section2', [
1407                 ('a', 'b'),
1408                 ('c', 'd'),
1409             ]),
1410             ('core 1', []),
1411             ('core 2', [
1412                 ('index', 8),
1413                 ('mode', ''),
1414             ]),
1415             ('core 3', [
1416                 ('index', 5),
1417                 ('mode', 'gen'),
1418                 ('name', 'tagged'),
1419             ]),
1420             ('core 4', [
1421                 ('index', 7),
1422                 ('mode', 'gen'),
1423                 ('name', 'udp'),
1424             ]),
1425         ]
1426
1427         expected_tagged = [7]
1428         expected_plain = [8]
1429         result_tagged, result_plain = helper.get_cores_mpls(helper.PROX_CORE_GEN_MODE)
1430         self.assertEqual(result_tagged, expected_tagged)
1431         self.assertEqual(result_plain, expected_plain)
1432
1433     def test_latency_cores(self):
1434         setup_helper = mock.MagicMock()
1435         setup_helper.prox_config_dict = {}
1436
1437         helper = ProxResourceHelper(setup_helper)
1438         helper._cpu_topology = []
1439
1440         expected = []
1441         result = helper.latency_cores
1442         self.assertEqual(result, expected)
1443
1444         setup_helper.prox_config_dict = [
1445             ('section1', []),
1446             ('section2', [
1447                 ('a', 'b'),
1448                 ('c', 'd'),
1449             ]),
1450             ('core 1s3', []),
1451             ('core 2s5', [
1452                 ('index', 8),
1453                 ('mode', ''),
1454             ]),
1455             ('core 3s1', [
1456                 ('index', 5),
1457                 ('mode', 'lat'),
1458             ]),
1459             ('core 4s9h', [
1460                 ('index', 7),
1461                 ('mode', 'lat'),
1462             ]),
1463         ]
1464
1465         helper = ProxResourceHelper(setup_helper)
1466         helper._cpu_topology = {
1467             1: {
1468                 3: {
1469                     'key1': (23, 32),
1470                     'key2': (12, 21),
1471                     'key3': (44, 33),
1472                 },
1473             },
1474             9: {
1475                 4: {
1476                     'key1': (44, 32),
1477                     'key2': (23, 21),
1478                     'key3': (12, 33),
1479                 },
1480             },
1481         }
1482
1483         self.assertIsNone(helper._latency_cores)
1484         expected = [12, 23]
1485         result = helper.latency_cores
1486         self.assertEqual(result, expected)
1487         self.assertIs(result, helper._latency_cores)
1488         self.assertIs(result, helper.latency_cores)
1489
1490     def test_run_traffic(self):
1491         setup_helper = mock.MagicMock()
1492         helper = ProxResourceHelper(setup_helper)
1493         traffic_proifle = mock.MagicMock(**{"done": True})
1494         helper.run_traffic(traffic_proifle)
1495         self.assertEqual(helper._terminated.value, 1)
1496
1497     def test__run_traffic_once(self):
1498         setup_helper = mock.MagicMock()
1499         helper = ProxResourceHelper(setup_helper)
1500         traffic_proifle = mock.MagicMock(**{"done": True})
1501         helper._run_traffic_once(traffic_proifle)
1502         self.assertEqual(helper._terminated.value, 1)
1503
1504     def test_start_collect(self):
1505         setup_helper = mock.MagicMock()
1506         helper = ProxResourceHelper(setup_helper)
1507         self.assertIsNone(helper.start_collect())
1508
1509     def test_terminate(self):
1510         setup_helper = mock.MagicMock()
1511         helper = ProxResourceHelper(setup_helper)
1512         with self.assertRaises(NotImplementedError):
1513             helper.terminate()
1514
1515     def test_up_post(self):
1516         setup_helper = mock.MagicMock()
1517         helper = ProxResourceHelper(setup_helper)
1518         helper.client = expected = mock.MagicMock()
1519         result = helper.up_post()
1520         self.assertEqual(result, expected)
1521
1522     def test_execute(self):
1523         setup_helper = mock.MagicMock()
1524         helper = ProxResourceHelper(setup_helper)
1525         helper.client = mock.MagicMock()
1526
1527         expected = helper.client.my_command()
1528         result = helper.execute('my_command')
1529         self.assertEqual(result, expected)
1530
1531         helper.client = object()
1532
1533         result = helper.execute('my_command')
1534         self.assertIsNone(result)
1535
1536     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
1537     def test_traffic_context(self, mock_time):
1538         setup_helper = mock.MagicMock()
1539         setup_helper.prox_config_dict = {}
1540
1541         helper = ProxResourceHelper(setup_helper)
1542         helper._cpu_topology = {
1543             0: {
1544                 1: {
1545                     5: (5, 1, 0)
1546                 },
1547                 2: {
1548                     6: (6, 2, 0)
1549                 },
1550                 3: {
1551                     7: (7, 3, 0)
1552                 },
1553                 4: {
1554                     8: (8, 3, 0)
1555                 },
1556             }
1557         }
1558
1559         setup_helper.prox_config_dict = [
1560             ('global', [
1561                 ('name', helper.PROX_CORE_MPLS_TEST)
1562             ]),
1563             ('section1', []),
1564             ('section2', [
1565                 ('a', 'b'),
1566                 ('c', 'd'),
1567             ]),
1568             ('core 1', []),
1569             ('core 2', [
1570                 ('index', 8),
1571                 ('mode', ''),
1572             ]),
1573             ('core 3', [
1574                 ('index', 5),
1575                 ('mode', 'gen'),
1576                 ('name', 'tagged'),
1577             ]),
1578             ('core 4', [
1579                 ('index', 7),
1580                 ('mode', 'gen'),
1581                 ('name', 'udp'),
1582             ]),
1583         ]
1584
1585         setup_helper = mock.MagicMock()
1586         setup_helper.vnfd_helper.interfaces = []
1587
1588         client = mock.MagicMock()
1589         client.hz.return_value = 2
1590         client.port_stats.return_value = tuple(range(12))
1591
1592         helper.client = client
1593         helper.get_latency = mock.MagicMock(return_value=[3.3, 3.6, 3.8])
1594
1595         helper._test_cores = [3, 4]
1596
1597         with helper.traffic_context(64, 1):
1598             pass
1599
1600     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
1601     def test_run_test(self, mock_time):
1602         @contextmanager
1603         def measure(*args, **kwargs):
1604             yield stats
1605
1606         setup_helper = mock.MagicMock()
1607         setup_helper.vnfd_helper.interfaces = []
1608
1609         stats = {
1610             'delta': TotStatsTuple(6, 7, 8, 9),
1611         }
1612
1613         client = mock.MagicMock()
1614         client.hz.return_value = 2
1615         client.measure_tot_stats = measure
1616         client.port_stats.return_value = tuple(range(12))
1617
1618         helper = ProxResourceHelper(setup_helper)
1619         helper.client = client
1620         helper.get_latency = mock.MagicMock(return_value=[3.3, 3.6, 3.8])
1621
1622         with self.assertRaises(AssertionError):
1623             helper.run_test(980, 15, 45)
1624
1625         setup_helper.vnfd_helper.interfaces = [
1626             {'name': 'a', 'virtual-interface': {'vpci': 'z'}},
1627             {'name': 'b', 'virtual-interface': {'vpci': 'y'}},
1628             {'name': 'c', 'virtual-interface': {'vpci': 'x'}},
1629             {'name': 'd', 'virtual-interface': {'vpci': 'w'}},
1630         ]
1631         helper._test_cores = [3, 4]
1632
1633         expected_test_data = ProxTestDataTuple(0.0, 2.0, 6, 7, 8, [3.3, 3.6, 3.8], 6, 7, 1.3e7)
1634         expected_port_samples = {
1635             'a': {'in_packets': 6, 'out_packets': 7},
1636             'b': {'in_packets': 6, 'out_packets': 7},
1637             'c': {'in_packets': 6, 'out_packets': 7},
1638             'd': {'in_packets': 6, 'out_packets': 7},
1639         }
1640         test_data, port_samples = helper.run_test(230, 60, 65)
1641         self.assertEqual(test_data, expected_test_data, '\n'.join(str(x) for x in test_data))
1642         self.assertEqual(port_samples, expected_port_samples,
1643                          '\n'.join(str(x) for x in port_samples))
1644
1645     def test_get_latency(self):
1646         setup_helper = mock.MagicMock()
1647         setup_helper.vnfd_helper.interfaces = []
1648
1649         helper = ProxResourceHelper(setup_helper)
1650         helper._latency_cores = []
1651
1652         expected = []
1653         result = helper.get_latency()
1654         self.assertEqual(result, expected)
1655
1656         helper._latency_cores = [1, 2]
1657         helper.client = mock.MagicMock()
1658
1659         expected = helper.sut.lat_stats()
1660         result = helper.get_latency()
1661         self.assertIs(result, expected)
1662
1663     def test__get_logical_if_name(self):
1664         setup_helper = mock.MagicMock()
1665         setup_helper.vnfd_helper.interfaces = []
1666
1667         helper = ProxResourceHelper(setup_helper)
1668         helper._vpci_to_if_name_map = {
1669             'key1': 234,
1670             'key2': 432,
1671         }
1672
1673         expected = 234
1674         result = helper._get_logical_if_name('key1')
1675         self.assertEqual(result, expected)
1676
1677     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.time')
1678     @mock.patch('yardstick.network_services.vnf_generic.vnf.prox_helpers.ProxSocketHelper')
1679     def test__connect(self, mock_socket_helper_type, mock_time):
1680         client = mock_socket_helper_type()
1681         client.connect.side_effect = chain(repeat(socket.error, 5), [None])
1682
1683         setup_helper = mock.MagicMock()
1684         setup_helper.vnfd_helper.interfaces = []
1685
1686         helper = ProxResourceHelper(setup_helper)
1687
1688         result = helper._connect()
1689         self.assertIs(result, client)
1690
1691         client.connect.side_effect = chain(repeat(socket.error, 65), [None])
1692
1693         with self.assertRaises(Exception):
1694             helper._connect()