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