yardstick/tests/unit/network_services/vnf_generic/vnf/test_tg_rfc2544_ixia.py

   1 # Copyright (c) 2016-2019 Intel Corporation
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #      http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 import os
  16
  17 import mock
  18 import six
  19 import unittest
  20 import ipaddress
  21 import time
  22 from collections import OrderedDict
  23
  24 from yardstick.common import utils
  25 from yardstick.common import exceptions
  26 from yardstick.benchmark import contexts
  27 from yardstick.benchmark.contexts import base as ctx_base
  28 from yardstick.network_services.libs.ixia_libs.ixnet import ixnet_api
  29 from yardstick.network_services.traffic_profile import base as tp_base
  30 from yardstick.network_services.vnf_generic.vnf import tg_rfc2544_ixia
  31 from yardstick.network_services.traffic_profile import ixia_rfc2544
  32
  33
  34 TEST_FILE_YAML = 'nsb_test_case.yaml'
  35
  36 NAME = "tg__1"
  37
  38
  39 class TestIxiaResourceHelper(unittest.TestCase):
  40
  41     def setUp(self):
  42         self._mock_IxNextgen = mock.patch.object(ixnet_api, 'IxNextgen')
  43         self.mock_IxNextgen = self._mock_IxNextgen.start()
  44         self.addCleanup(self._stop_mocks)
  45
  46     def _stop_mocks(self):
  47         self._mock_IxNextgen.stop()
  48
  49     def test___init___with_custom_rfc_helper(self):
  50         class MyRfcHelper(tg_rfc2544_ixia.IxiaRfc2544Helper):
  51             pass
  52
  53         ixia_resource_helper = tg_rfc2544_ixia.IxiaResourceHelper(
  54             mock.Mock(), MyRfcHelper)
  55         self.assertIsInstance(ixia_resource_helper.rfc_helper, MyRfcHelper)
  56
  57     def test__init_ix_scenario(self):
  58         mock_scenario = mock.Mock()
  59         mock_scenario_helper = mock.Mock()
  60         mock_scenario_helper.scenario_cfg = {'ixia_config': 'TestScenario',
  61                                              'options': 'scenario_options'}
  62         mock_setup_helper = mock.Mock(scenario_helper=mock_scenario_helper)
  63         ixia_resource_helper = tg_rfc2544_ixia.IxiaResourceHelper(mock_setup_helper)
  64         ixia_resource_helper._ixia_scenarios = {'TestScenario': mock_scenario}
  65         ixia_resource_helper.client = 'client'
  66         ixia_resource_helper.context_cfg = 'context'
  67         ixia_resource_helper._init_ix_scenario()
  68         mock_scenario.assert_called_once_with('client', 'context', 'scenario_options')
  69
  70     def test__init_ix_scenario_not_supported_cfg_type(self):
  71         mock_scenario_helper = mock.Mock()
  72         mock_scenario_helper.scenario_cfg = {'ixia_config': 'FakeScenario',
  73                                              'options': 'scenario_options'}
  74         mock_setup_helper = mock.Mock(scenario_helper=mock_scenario_helper)
  75         ixia_resource_helper = tg_rfc2544_ixia.IxiaResourceHelper(mock_setup_helper)
  76         ixia_resource_helper._ixia_scenarios = {'TestScenario': mock.Mock()}
  77         with self.assertRaises(RuntimeError):
  78             ixia_resource_helper._init_ix_scenario()
  79
  80     @mock.patch.object(tg_rfc2544_ixia.IxiaResourceHelper, '_init_ix_scenario')
  81     def test_setup(self, mock__init_ix_scenario):
  82         ixia_resource_helper = tg_rfc2544_ixia.IxiaResourceHelper(mock.Mock())
  83         ixia_resource_helper.setup()
  84         mock__init_ix_scenario.assert_called_once()
  85
  86     def test_stop_collect_with_client(self):
  87         mock_client = mock.Mock()
  88         ixia_resource_helper = tg_rfc2544_ixia.IxiaResourceHelper(mock.Mock())
  89         ixia_resource_helper.client = mock_client
  90         ixia_resource_helper._ix_scenario = mock.Mock()
  91         ixia_resource_helper.stop_collect()
  92         self.assertEqual(1, ixia_resource_helper._terminated.value)
  93         ixia_resource_helper._ix_scenario.stop_protocols.assert_called_once()
  94
  95     def test_run_traffic(self):
  96         mock_tprofile = mock.Mock()
  97         mock_tprofile.config.duration = 10
  98         mock_tprofile.get_drop_percentage.return_value = True, 'fake_samples'
  99         ixia_rhelper = tg_rfc2544_ixia.IxiaResourceHelper(mock.Mock())
 100         ixia_rhelper.rfc_helper = mock.Mock()
 101         ixia_rhelper.vnfd_helper = mock.Mock()
 102         ixia_rhelper._ix_scenario = mock.Mock()
 103         ixia_rhelper.vnfd_helper.port_pairs.all_ports = []
 104         with mock.patch.object(ixia_rhelper, 'generate_samples'), \
 105                 mock.patch.object(ixia_rhelper, '_build_ports'), \
 106                 mock.patch.object(ixia_rhelper, '_initialize_client'), \
 107                 mock.patch.object(utils, 'wait_until_true'):
 108             ixia_rhelper.run_traffic(mock_tprofile)
 109
 110         self.assertEqual('fake_samples', ixia_rhelper._queue.get())
 111         mock_tprofile.update_traffic_profile.assert_called_once()
 112
 113     def test_run_test(self):
 114         expected_result = {'test': 'fake_samples', 'Iteration': 1}
 115         mock_tprofile = mock.Mock()
 116         mock_tprofile.config.duration = 10
 117         mock_tprofile.get_drop_percentage.return_value = \
 118             True, {'test': 'fake_samples'}
 119         ixia_rhelper = tg_rfc2544_ixia.IxiaResourceHelper(mock.Mock())
 120         tasks_queue = mock.Mock()
 121         tasks_queue.get.return_value = 'RUN_TRAFFIC'
 122         results_queue = mock.Mock()
 123         ixia_rhelper.rfc_helper = mock.Mock()
 124         ixia_rhelper.vnfd_helper = mock.Mock()
 125         ixia_rhelper._ix_scenario = mock.Mock()
 126         ixia_rhelper.vnfd_helper.port_pairs.all_ports = []
 127         with mock.patch.object(ixia_rhelper, 'generate_samples'), \
 128                 mock.patch.object(ixia_rhelper, '_build_ports'), \
 129                 mock.patch.object(ixia_rhelper, '_initialize_client'), \
 130                 mock.patch.object(utils, 'wait_until_true'):
 131             ixia_rhelper.run_test(mock_tprofile, tasks_queue, results_queue)
 132
 133         self.assertEqual(expected_result, ixia_rhelper._queue.get())
 134         mock_tprofile.update_traffic_profile.assert_called_once()
 135         tasks_queue.task_done.assert_called_once()
 136         results_queue.put.assert_called_once_with('COMPLETE')
 137
 138
 139 @mock.patch.object(tg_rfc2544_ixia, 'ixnet_api')
 140 class TestIXIATrafficGen(unittest.TestCase):
 141     VNFD = {'vnfd:vnfd-catalog':
 142             {'vnfd':
 143              [{'short-name': 'VpeVnf',
 144                'vdu':
 145                [{'routing_table':
 146                              [{'network': '152.16.100.20',
 147                                'netmask': '255.255.255.0',
 148                                'gateway': '152.16.100.20',
 149                                'if': 'xe0'},
 150                               {'network': '152.16.40.20',
 151                                'netmask': '255.255.255.0',
 152                                'gateway': '152.16.40.20',
 153                                'if': 'xe1'}],
 154                              'description': 'VPE approximation using DPDK',
 155                              'name': 'vpevnf-baremetal',
 156                              'nd_route_tbl':
 157                                  [{'network': '0064:ff9b:0:0:0:0:9810:6414',
 158                                    'netmask': '112',
 159                                    'gateway': '0064:ff9b:0:0:0:0:9810:6414',
 160                                    'if': 'xe0'},
 161                                   {'network': '0064:ff9b:0:0:0:0:9810:2814',
 162                                    'netmask': '112',
 163                                    'gateway': '0064:ff9b:0:0:0:0:9810:2814',
 164                                    'if': 'xe1'}],
 165                              'id': 'vpevnf-baremetal',
 166                              'external-interface':
 167                                  [{'virtual-interface':
 168                                    {'dst_mac': '00:00:00:00:00:04',
 169                                     'vpci': '0000:05:00.0',
 170                                     'local_ip': '152.16.100.19',
 171                                     'type': 'PCI-PASSTHROUGH',
 172                                     'netmask': '255.255.255.0',
 173                                     'dpdk_port_num': 0,
 174                                     'bandwidth': '10 Gbps',
 175                                     'driver': "i40e",
 176                                     'dst_ip': '152.16.100.20',
 177                                     'local_iface_name': 'xe0',
 178                                     'local_mac': '00:00:00:00:00:02'},
 179                                    'vnfd-connection-point-ref': 'xe0',
 180                                    'name': 'xe0'},
 181                                   {'virtual-interface':
 182                                    {'dst_mac': '00:00:00:00:00:03',
 183                                     'vpci': '0000:05:00.1',
 184                                     'local_ip': '152.16.40.19',
 185                                     'type': 'PCI-PASSTHROUGH',
 186                                     'driver': "i40e",
 187                                     'netmask': '255.255.255.0',
 188                                     'dpdk_port_num': 1,
 189                                     'bandwidth': '10 Gbps',
 190                                     'dst_ip': '152.16.40.20',
 191                                     'local_iface_name': 'xe1',
 192                                     'local_mac': '00:00:00:00:00:01'},
 193                                    'vnfd-connection-point-ref': 'xe1',
 194                                    'name': 'xe1'}]}],
 195                'description': 'Vpe approximation using DPDK',
 196                'mgmt-interface':
 197                {'vdu-id': 'vpevnf-baremetal',
 198                 'host': '1.1.1.1',
 199                 'password': 'r00t',
 200                             'user': 'root',
 201                             'ip': '1.1.1.1'},
 202                'benchmark':
 203                {'kpi': ['packets_in', 'packets_fwd',
 204                         'packets_dropped']},
 205                'connection-point': [{'type': 'VPORT', 'name': 'xe0'},
 206                                     {'type': 'VPORT', 'name': 'xe1'}],
 207                'id': 'VpeApproxVnf', 'name': 'VPEVnfSsh'}]}}
 208
 209     TRAFFIC_PROFILE = {
 210         "schema": "isb:traffic_profile:0.1",
 211         "name": "fixed",
 212         "description": "Fixed traffic profile to run UDP traffic",
 213         "traffic_profile": {
 214             "traffic_type": "FixedTraffic",
 215             "frame_rate": 100,  # pps
 216             "flow_number": 10,
 217             "frame_size": 64}}
 218
 219     TC_YAML = {'scenarios': [{'tc_options':
 220                               {'rfc2544': {'allowed_drop_rate': '0.8 - 1'}},
 221                               'runner': {'duration': 400,
 222                                          'interval': 35, 'type': 'Duration'},
 223                               'traffic_options':
 224                                   {'flow': 'ipv4_1flow_Packets_vpe.yaml',
 225                                    'imix': 'imix_voice.yaml'},
 226                               'vnf_options': {'vpe': {'cfg': 'vpe_config'}},
 227                               'traffic_profile': 'ipv4_throughput_vpe.yaml',
 228                               'type': 'NSPerf',
 229                               'nodes': {'tg__1': 'trafficgen_1.yardstick',
 230                                         'vnf__1': 'vnf.yardstick'},
 231                               'topology': 'vpe_vnf_topology.yaml'}],
 232                'context': {'nfvi_type': 'baremetal',
 233                            'type': contexts.CONTEXT_NODE,
 234                            'name': 'yardstick',
 235                            'file': '/etc/yardstick/nodes/pod.yaml'},
 236                'schema': 'yardstick:task:0.1'}
 237
 238     def test___init__(self, *args):
 239         with mock.patch("yardstick.ssh.SSH") as ssh:
 240             ssh_mock = mock.Mock(autospec=ssh.SSH)
 241             ssh_mock.execute = \
 242                 mock.Mock(return_value=(0, "", ""))
 243             ssh.from_node.return_value = ssh_mock
 244             vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
 245             # NOTE(ralonsoh): check the object returned.
 246             tg_rfc2544_ixia.IxiaTrafficGen(NAME, vnfd)
 247
 248     def test_listen_traffic(self, *args):
 249         with mock.patch("yardstick.ssh.SSH") as ssh:
 250             ssh_mock = mock.Mock(autospec=ssh.SSH)
 251             ssh_mock.execute = \
 252                 mock.Mock(return_value=(0, "", ""))
 253             ssh.from_node.return_value = ssh_mock
 254             vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
 255             ixnet_traffic_gen = tg_rfc2544_ixia.IxiaTrafficGen(NAME, vnfd)
 256             self.assertIsNone(ixnet_traffic_gen.listen_traffic({}))
 257
 258     @mock.patch.object(ctx_base.Context, 'get_context_from_server', return_value='fake_context')
 259     def test_instantiate(self, *args):
 260         with mock.patch("yardstick.ssh.SSH") as ssh:
 261             ssh_mock = mock.Mock(autospec=ssh.SSH)
 262             ssh_mock.execute = \
 263                 mock.Mock(return_value=(0, "", ""))
 264             ssh_mock.run = \
 265                 mock.Mock(return_value=(0, "", ""))
 266             ssh.from_node.return_value = ssh_mock
 267             vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
 268             ixnet_traffic_gen = tg_rfc2544_ixia.IxiaTrafficGen(NAME, vnfd)
 269             scenario_cfg = {'tc': "nsb_test_case",
 270                             "topology": ""}
 271             scenario_cfg.update(
 272                 {
 273                     'options': {
 274                         'packetsize': 64,
 275                         'traffic_type': 4,
 276                         'rfc2544': {
 277                             'allowed_drop_rate': '0.8 - 1'},
 278                         'vnf__1': {
 279                             'rules': 'acl_1rule.yaml',
 280                             'vnf_config': {
 281                                 'lb_config': 'SW',
 282                                 'lb_count': 1,
 283                                 'worker_config': '1C/1T',
 284                                 'worker_threads': 1}}}})
 285             scenario_cfg.update({
 286                 'nodes': {ixnet_traffic_gen.name: "mock"}
 287             })
 288             ixnet_traffic_gen.topology = ""
 289             ixnet_traffic_gen.get_ixobj = mock.MagicMock()
 290             ixnet_traffic_gen._ixia_traffic_gen = mock.MagicMock()
 291             ixnet_traffic_gen._ixia_traffic_gen._connect = mock.Mock()
 292             self.assertRaises(
 293                 IOError,
 294                 ixnet_traffic_gen.instantiate(scenario_cfg, {}))
 295
 296     @mock.patch.object(ctx_base.Context, 'get_physical_node_from_server', return_value='mock_node')
 297     def test_collect_kpi(self, *args):
 298         with mock.patch("yardstick.ssh.SSH") as ssh:
 299             ssh_mock = mock.Mock(autospec=ssh.SSH)
 300             ssh_mock.execute = \
 301                 mock.Mock(return_value=(0, "", ""))
 302             ssh.from_node.return_value = ssh_mock
 303
 304             vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
 305             ixnet_traffic_gen = tg_rfc2544_ixia.IxiaTrafficGen(NAME, vnfd)
 306             ixnet_traffic_gen.scenario_helper.scenario_cfg = {
 307                 'nodes': {ixnet_traffic_gen.name: "mock"}
 308             }
 309             ixnet_traffic_gen.data = {}
 310             restult = ixnet_traffic_gen.collect_kpi()
 311
 312             expected = {'collect_stats': {},
 313                         'physical_node': 'mock_node'}
 314
 315             self.assertEqual(expected, restult)
 316
 317     def test_terminate(self, *args):
 318         with mock.patch("yardstick.ssh.SSH") as ssh:
 319             vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
 320             ssh_mock = mock.Mock(autospec=ssh.SSH)
 321             ssh_mock.execute = \
 322                 mock.Mock(return_value=(0, "", ""))
 323             ssh.from_node.return_value = ssh_mock
 324             ixnet_traffic_gen = tg_rfc2544_ixia.IxiaTrafficGen(
 325                 NAME, vnfd, resource_helper_type=mock.Mock())
 326             ixnet_traffic_gen._terminated = mock.MagicMock()
 327             ixnet_traffic_gen._terminated.value = 0
 328             ixnet_traffic_gen._ixia_traffic_gen = mock.MagicMock()
 329             ixnet_traffic_gen._ixia_traffic_gen.ix_stop_traffic = mock.Mock()
 330             ixnet_traffic_gen._traffic_process = mock.MagicMock()
 331             ixnet_traffic_gen._traffic_process.terminate = mock.Mock()
 332             self.assertIsNone(ixnet_traffic_gen.terminate())
 333
 334     def _get_file_abspath(self, filename):
 335         curr_path = os.path.dirname(os.path.abspath(__file__))
 336         file_path = os.path.join(curr_path, filename)
 337         return file_path
 338
 339     def test__check_status(self, *args):
 340         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
 341         sut = tg_rfc2544_ixia.IxiaTrafficGen('vnf1', vnfd)
 342         sut._check_status()
 343
 344     @mock.patch("yardstick.ssh.SSH")
 345     def test_traffic_runner(self, mock_ssh, *args):
 346         mock_traffic_profile = mock.Mock(autospec=tp_base.TrafficProfile)
 347         mock_traffic_profile.get_traffic_definition.return_value = "64"
 348         mock_traffic_profile.params = self.TRAFFIC_PROFILE
 349         # traffic_profile.ports is standardized on port_num
 350         mock_traffic_profile.ports = [0, 1]
 351
 352         mock_ssh_instance = mock.Mock(autospec=mock_ssh.SSH)
 353         mock_ssh_instance.execute.return_value = 0, "", ""
 354         mock_ssh_instance.run.return_value = 0, "", ""
 355
 356         mock_ssh.from_node.return_value = mock_ssh_instance
 357
 358         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
 359         vnfd["mgmt-interface"].update({
 360             'tg-config': {
 361                 "ixchassis": "1.1.1.1",
 362                 "py_bin_path": "/root",
 363             }
 364         })
 365
 366         samples = {}
 367         name = ''
 368         for ifname in range(1):
 369             name = "xe{}".format(ifname)
 370             samples[name] = {
 371                 "Rx_Rate_Kbps": 20,
 372                 "Tx_Rate_Kbps": 20,
 373                 "Rx_Rate_Mbps": 10,
 374                 "Tx_Rate_Mbps": 10,
 375                 "RxThroughput": 10,
 376                 "TxThroughput": 10,
 377                 "Valid_Frames_Rx": 1000,
 378                 "Frames_Tx": 1000,
 379                 "in_packets": 1000,
 380                 "out_packets": 1000,
 381             }
 382
 383         samples.update({"CurrentDropPercentage": 0.0})
 384
 385         last_res = [
 386             0,
 387             {
 388                 "Rx_Rate_Kbps": [20, 20],
 389                 "Tx_Rate_Kbps": [20, 20],
 390                 "Rx_Rate_Mbps": [10, 10],
 391                 "Tx_Rate_Mbps": [10, 10],
 392                 "CurrentDropPercentage": [0, 0],
 393                 "RxThroughput": [10, 10],
 394                 "TxThroughput": [10, 10],
 395                 "Frames_Tx": [1000, 1000],
 396                 "in_packets": [1000, 1000],
 397                 "Valid_Frames_Rx": [1000, 1000],
 398                 "out_packets": [1000, 1000],
 399             },
 400         ]
 401
 402         mock_traffic_profile.execute_traffic.return_value = [
 403             'Completed', samples]
 404         mock_traffic_profile.get_drop_percentage.return_value = [
 405             'Completed', samples]
 406
 407         sut = tg_rfc2544_ixia.IxiaTrafficGen(name, vnfd)
 408         sut.vnf_port_pairs = [[[0], [1]]]
 409         sut.tc_file_name = self._get_file_abspath(TEST_FILE_YAML)
 410         sut.topology = ""
 411
 412         sut.ssh_helper = mock.Mock()
 413         sut._traffic_process = mock.MagicMock()
 414         sut.generate_port_pairs = mock.Mock()
 415
 416         sut._ixia_traffic_gen = mock.MagicMock()
 417         sut._ixia_traffic_gen.ix_get_statistics.return_value = last_res
 418
 419         sut.resource_helper.client = mock.MagicMock()
 420         sut.resource_helper.client_started = mock.MagicMock()
 421         sut.resource_helper.client_started.value = 1
 422         sut.resource_helper.rfc_helper.iteration.value = 11
 423         sut.resource_helper._ix_scenario = mock.Mock()
 424
 425         sut.scenario_helper.scenario_cfg = {
 426             'options': {
 427                 'packetsize': 64,
 428                 'traffic_type': 4,
 429                 'rfc2544': {
 430                     'allowed_drop_rate': '0.8 - 1',
 431                     'latency': True
 432                 },
 433                 'vnf__1': {
 434                     'rules': 'acl_1rule.yaml',
 435                     'vnf_config': {
 436                         'lb_config': 'SW',
 437                         'lb_count': 1,
 438                         'worker_config': '1C/1T',
 439                         'worker_threads': 1,
 440                     },
 441                 },
 442             },
 443             'task_path': '/path/to/task'
 444         }
 445
 446         @mock.patch.object(six.moves.builtins, 'open', create=True)
 447         @mock.patch('yardstick.network_services.vnf_generic.vnf.tg_rfc2544_ixia.open',
 448                     mock.mock_open(), create=True)
 449         @mock.patch('yardstick.network_services.vnf_generic.vnf.tg_rfc2544_ixia.LOG.exception')
 450         def _traffic_runner(*args):
 451             result = sut._traffic_runner(mock_traffic_profile)
 452             self.assertIsNone(result)
 453
 454         _traffic_runner()
 455
 456     def test_run_traffic_once(self, *args):
 457         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
 458         sut = tg_rfc2544_ixia.IxiaTrafficGen('vnf1', vnfd)
 459         sut._init_traffic_process = mock.Mock()
 460         sut._tasks_queue.put = mock.Mock()
 461         sut.resource_helper.client_started.value = 0
 462         sut.run_traffic_once(self.TRAFFIC_PROFILE)
 463         sut._tasks_queue.put.assert_called_once_with("RUN_TRAFFIC")
 464         sut._init_traffic_process.assert_called_once_with(self.TRAFFIC_PROFILE)
 465
 466     def test__test_runner(self, *args):
 467         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
 468         sut = tg_rfc2544_ixia.IxiaTrafficGen('vnf1', vnfd)
 469         tasks = 'tasks'
 470         results = 'results'
 471         sut.resource_helper = mock.Mock()
 472         sut._test_runner(self.TRAFFIC_PROFILE, tasks, results)
 473         sut.resource_helper.run_test.assert_called_once_with(self.TRAFFIC_PROFILE,
 474                                                              tasks, results)
 475
 476     @mock.patch.object(time, 'sleep', return_value=0)
 477     def test__init_traffic_process(self, *args):
 478         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
 479         sut = tg_rfc2544_ixia.IxiaTrafficGen('vnf1', vnfd)
 480         sut._test_runner = mock.Mock(return_value=0)
 481         sut.resource_helper = mock.Mock()
 482         sut.resource_helper.client_started.value = 0
 483         sut._init_traffic_process(self.TRAFFIC_PROFILE)
 484
 485     def test_wait_on_traffic(self, *args):
 486         vnfd = self.VNFD['vnfd:vnfd-catalog']['vnfd'][0]
 487         sut = tg_rfc2544_ixia.IxiaTrafficGen('vnf1', vnfd)
 488         sut._tasks_queue.join = mock.Mock(return_value=0)
 489         sut._result_queue.get = mock.Mock(return_value='COMPLETE')
 490         result = sut.wait_on_traffic()
 491         sut._tasks_queue.join.assert_called_once()
 492         sut._result_queue.get.assert_called_once()
 493         self.assertEqual(result, 'COMPLETE')
 494
 495
 496 class TestIxiaBasicScenario(unittest.TestCase):
 497
 498     STATS = {'stat_name': ['Card01/Port01',
 499                            'Card02/Port02'],
 500              'port_name': ['Ethernet - 001', 'Ethernet - 002'],
 501              'Frames_Tx': ['150', '150'],
 502              'Valid_Frames_Rx': ['150', '150'],
 503              'Frames_Tx_Rate': ['0.0', '0.0'],
 504              'Valid_Frames_Rx_Rate': ['0.0', '0.0'],
 505              'Bytes_Rx': ['9600', '9600'],
 506              'Bytes_Tx': ['9600', '9600'],
 507              'Tx_Rate_Kbps': ['0.0', '0.0'],
 508              'Rx_Rate_Mbps': ['0.0', '0.0'],
 509              'Tx_Rate_Mbps': ['0.0', '0.0'],
 510              'Rx_Rate_Kbps': ['0.0', '0.0'],
 511              'Store-Forward_Max_latency_ns': ['100', '200'],
 512              'Store-Forward_Min_latency_ns': ['100', '200'],
 513              'Store-Forward_Avg_latency_ns': ['100', '200']}
 514
 515     def setUp(self):
 516         self._mock_IxNextgen = mock.patch.object(ixnet_api, 'IxNextgen')
 517         self.mock_IxNextgen = self._mock_IxNextgen.start()
 518         self.context_cfg = mock.Mock()
 519         self.ixia_cfg = mock.Mock()
 520         self.scenario = tg_rfc2544_ixia.IxiaBasicScenario(self.mock_IxNextgen,
 521                                                           self.context_cfg,
 522                                                           self.ixia_cfg)
 523         self.addCleanup(self._stop_mocks)
 524
 525     def _stop_mocks(self):
 526         self._mock_IxNextgen.stop()
 527
 528     def test___init___(self):
 529         self.assertIsInstance(self.scenario, tg_rfc2544_ixia.IxiaBasicScenario)
 530         self.assertEqual(self.scenario.client, self.mock_IxNextgen)
 531
 532     def test_create_traffic_model(self):
 533         self.mock_IxNextgen.get_vports.return_value = [1, 2, 3, 4]
 534         yaml_data = {'traffic_profile': {}
 535                     }
 536         traffic_profile = ixia_rfc2544.IXIARFC2544Profile(yaml_data)
 537         self.scenario.create_traffic_model(traffic_profile)
 538         self.scenario.client.get_vports.assert_called_once()
 539         self.scenario.client.create_traffic_model.assert_called_once_with(
 540             [1, 3], [2, 4], traffic_profile)
 541
 542     def test_apply_config(self):
 543         self.assertIsNone(self.scenario.apply_config())
 544
 545     def test_run_protocols(self):
 546         self.assertIsNone(self.scenario.run_protocols())
 547
 548     def test_stop_protocols(self):
 549         self.assertIsNone(self.scenario.stop_protocols())
 550
 551     def test__get_stats(self):
 552         self.scenario._get_stats()
 553         self.scenario.client.get_statistics.assert_called_once()
 554
 555     @mock.patch.object(tg_rfc2544_ixia.IxiaBasicScenario, '_get_stats')
 556     def test_generate_samples(self, mock_get_stats):
 557
 558         expected_samples = {'xe0': {
 559                                 'in_packets': 150,
 560                                 'out_packets': 150,
 561                                 'in_bytes': 9600,
 562                                 'out_bytes': 9600,
 563                                 'rx_throughput_mbps': 0.0,
 564                                 'rx_throughput_kps': 0.0,
 565                                 'RxThroughput': 5.0,
 566                                 'TxThroughput': 5.0,
 567                                 'RxThroughputBps': 320.0,
 568                                 'TxThroughputBps': 320.0,
 569                                 'tx_throughput_mbps': 0.0,
 570                                 'tx_throughput_kps': 0.0,
 571                                 'Store-Forward_Max_latency_ns': 100,
 572                                 'Store-Forward_Min_latency_ns': 100,
 573                                 'Store-Forward_Avg_latency_ns': 100},
 574                             'xe1': {
 575                                 'in_packets': 150,
 576                                 'out_packets': 150,
 577                                 'in_bytes': 9600,
 578                                 'out_bytes': 9600,
 579                                 'rx_throughput_mbps': 0.0,
 580                                 'rx_throughput_kps': 0.0,
 581                                 'RxThroughput': 5.0,
 582                                 'TxThroughput': 5.0,
 583                                 'RxThroughputBps': 320.0,
 584                                 'TxThroughputBps': 320.0,
 585                                 'tx_throughput_mbps': 0.0,
 586                                 'tx_throughput_kps': 0.0,
 587                                 'Store-Forward_Max_latency_ns': 200,
 588                                 'Store-Forward_Min_latency_ns': 200,
 589                                 'Store-Forward_Avg_latency_ns': 200}}
 590
 591         res_helper = mock.Mock()
 592         res_helper.vnfd_helper.find_interface_by_port.side_effect = \
 593             [{'name': 'xe0'}, {'name': 'xe1'}]
 594         ports = [0, 1]
 595         duration = 30
 596         mock_get_stats.return_value = self.STATS
 597         samples = self.scenario.generate_samples(res_helper, ports, duration)
 598         mock_get_stats.assert_called_once()
 599         self.assertEqual(samples, expected_samples)
 600
 601
 602 class TestIxiaL3Scenario(TestIxiaBasicScenario):
 603     IXIA_CFG = {
 604         'flow': {
 605             'src_ip': ['192.168.0.1-192.168.0.50'],
 606             'dst_ip': ['192.168.1.1-192.168.1.150']
 607         }
 608     }
 609
 610     CONTEXT_CFG = {
 611         'nodes': {
 612             'tg__0': {
 613                 'role': 'IxNet',
 614                 'interfaces': {
 615                     'xe0': {
 616                         'vld_id': 'uplink_0',
 617                         'local_ip': '10.1.1.1',
 618                         'local_mac': 'aa:bb:cc:dd:ee:ff',
 619                         'ifname': 'xe0'
 620                     },
 621                     'xe1': {
 622                         'vld_id': 'downlink_0',
 623                         'local_ip': '20.2.2.2',
 624                         'local_mac': 'bb:bb:cc:dd:ee:ee',
 625                         'ifname': 'xe1'
 626                     }
 627                 },
 628                 'routing_table': [{
 629                     'network': "152.16.100.20",
 630                     'netmask': '255.255.0.0',
 631                     'gateway': '152.16.100.21',
 632                     'if': 'xe0'
 633                 }]
 634             }
 635         }
 636     }
 637
 638     def setUp(self):
 639         super(TestIxiaL3Scenario, self).setUp()
 640         self.ixia_cfg = self.IXIA_CFG
 641         self.context_cfg = self.CONTEXT_CFG
 642         self.scenario = tg_rfc2544_ixia.IxiaL3Scenario(self.mock_IxNextgen,
 643                                                        self.context_cfg,
 644                                                        self.ixia_cfg)
 645
 646     def test___init___(self):
 647         self.assertIsInstance(self.scenario, tg_rfc2544_ixia.IxiaL3Scenario)
 648         self.assertEqual(self.scenario.client, self.mock_IxNextgen)
 649
 650     def test_create_traffic_model(self):
 651         self.mock_IxNextgen.get_vports.return_value = ['1', '2']
 652         self.scenario.create_traffic_model()
 653         self.scenario.client.get_vports.assert_called_once()
 654         self.scenario.client.create_ipv4_traffic_model.\
 655             assert_called_once_with(['1/protocols/static'],
 656                                     ['2/protocols/static'])
 657
 658     def test_apply_config(self):
 659         self.scenario._add_interfaces = mock.Mock()
 660         self.scenario._add_static_ips = mock.Mock()
 661         self.assertIsNone(self.scenario.apply_config())
 662
 663     def test__add_static(self):
 664         self.mock_IxNextgen.get_vports.return_value = ['1', '2']
 665         self.mock_IxNextgen.get_static_interface.side_effect = ['intf1',
 666                                                                 'intf2']
 667
 668         self.scenario._add_static_ips()
 669
 670         self.mock_IxNextgen.get_static_interface.assert_any_call('1')
 671         self.mock_IxNextgen.get_static_interface.assert_any_call('2')
 672
 673         self.scenario.client.add_static_ipv4.assert_any_call(
 674             'intf1', '1', '192.168.0.1', 49, '32')
 675         self.scenario.client.add_static_ipv4.assert_any_call(
 676             'intf2', '2', '192.168.1.1', 149, '32')
 677
 678     def test__add_interfaces(self):
 679         self.mock_IxNextgen.get_vports.return_value = ['1', '2']
 680
 681         self.scenario._add_interfaces()
 682
 683         self.mock_IxNextgen.add_interface.assert_any_call('1',
 684                                                           '10.1.1.1',
 685                                                           'aa:bb:cc:dd:ee:ff',
 686                                                           '152.16.100.21')
 687         self.mock_IxNextgen.add_interface.assert_any_call('2',
 688                                                           '20.2.2.2',
 689                                                           'bb:bb:cc:dd:ee:ee',
 690                                                           None)
 691
 692
 693 class TestIxiaPppoeClientScenario(unittest.TestCase):
 694
 695     IXIA_CFG = {
 696         'pppoe_client': {
 697             'sessions_per_port': 4,
 698             'sessions_per_svlan': 1,
 699             's_vlan': 10,
 700             'c_vlan': 20,
 701             'ip': ['10.3.3.1', '10.4.4.1']
 702         },
 703         'ipv4_client': {
 704             'sessions_per_port': 1,
 705             'sessions_per_vlan': 1,
 706             'vlan': 101,
 707             'gateway_ip': ['10.1.1.1', '10.2.2.1'],
 708             'ip': ['10.1.1.1', '10.2.2.1'],
 709             'prefix': ['24', '24']
 710         },
 711         'priority': {
 712             'tos': {'precedence': [0, 4]}
 713         }
 714     }
 715
 716     CONTEXT_CFG = {
 717         'nodes': {'tg__0': {
 718             'interfaces': {'xe0': {
 719                 'local_ip': '10.1.1.1',
 720                 'netmask': '255.255.255.0'
 721                 }}}}}
 722
 723     def setUp(self):
 724         self._mock_IxNextgen = mock.patch.object(ixnet_api, 'IxNextgen')
 725         self.mock_IxNextgen = self._mock_IxNextgen.start()
 726         self.scenario = tg_rfc2544_ixia.IxiaPppoeClientScenario(
 727             self.mock_IxNextgen, self.CONTEXT_CFG, self.IXIA_CFG)
 728         tg_rfc2544_ixia.WAIT_PROTOCOLS_STARTED = 2
 729         self.addCleanup(self._stop_mocks)
 730
 731     def _stop_mocks(self):
 732         self._mock_IxNextgen.stop()
 733
 734     def test___init___(self):
 735         self.assertIsInstance(self.scenario, tg_rfc2544_ixia.IxiaPppoeClientScenario)
 736         self.assertEqual(self.scenario.client, self.mock_IxNextgen)
 737
 738     @mock.patch.object(tg_rfc2544_ixia.IxiaPppoeClientScenario,
 739                        '_fill_ixia_config')
 740     @mock.patch.object(tg_rfc2544_ixia.IxiaPppoeClientScenario,
 741                        '_apply_access_network_config')
 742     @mock.patch.object(tg_rfc2544_ixia.IxiaPppoeClientScenario,
 743                        '_apply_core_network_config')
 744     def test_apply_config(self, mock_apply_core_net_cfg,
 745                           mock_apply_access_net_cfg,
 746                           mock_fill_ixia_config):
 747         self.mock_IxNextgen.get_vports.return_value = [1, 2, 3, 4]
 748         self.scenario.apply_config()
 749         self.scenario.client.get_vports.assert_called_once()
 750         self.assertEqual(self.scenario._uplink_vports, [1, 3])
 751         self.assertEqual(self.scenario._downlink_vports, [2, 4])
 752         mock_fill_ixia_config.assert_called_once()
 753         mock_apply_core_net_cfg.assert_called_once()
 754         mock_apply_access_net_cfg.assert_called_once()
 755
 756     @mock.patch.object(tg_rfc2544_ixia.IxiaPppoeClientScenario,
 757                        '_get_endpoints_src_dst_id_pairs')
 758     @mock.patch.object(tg_rfc2544_ixia.IxiaPppoeClientScenario,
 759                        '_get_endpoints_src_dst_obj_pairs')
 760     def test_create_traffic_model(self, mock_obj_pairs, mock_id_pairs):
 761         uplink_endpoints = ['group1', 'group2']
 762         downlink_endpoints = ['group3', 'group3']
 763         mock_id_pairs.return_value = ['xe0', 'xe1', 'xe0', 'xe1']
 764         mock_obj_pairs.return_value = ['group1', 'group3', 'group2', 'group3']
 765         mock_tp = mock.Mock()
 766         mock_tp.full_profile = {'uplink_0': 'data',
 767                                 'downlink_0': 'data',
 768                                 'uplink_1': 'data',
 769                                 'downlink_1': 'data'
 770                                 }
 771         self.scenario.create_traffic_model(mock_tp)
 772         mock_id_pairs.assert_called_once_with(mock_tp.full_profile)
 773         mock_obj_pairs.assert_called_once_with(['xe0', 'xe1', 'xe0', 'xe1'])
 774         self.scenario.client.create_ipv4_traffic_model.assert_called_once_with(
 775             uplink_endpoints, downlink_endpoints)
 776
 777     @mock.patch.object(tg_rfc2544_ixia.IxiaPppoeClientScenario,
 778                        '_get_endpoints_src_dst_id_pairs')
 779     @mock.patch.object(tg_rfc2544_ixia.IxiaPppoeClientScenario,
 780                        '_get_endpoints_src_dst_obj_pairs')
 781     def test_create_traffic_model_topology_based_flows(self, mock_obj_pairs,
 782                                                        mock_id_pairs):
 783         uplink_topologies = ['topology1', 'topology3']
 784         downlink_topologies = ['topology2', 'topology4']
 785         mock_id_pairs.return_value = []
 786         mock_obj_pairs.return_value = []
 787         mock_tp = mock.Mock()
 788         mock_tp.full_profile = {'uplink_0': 'data',
 789                                 'downlink_0': 'data',
 790                                 'uplink_1': 'data',
 791                                 'downlink_1': 'data'
 792                                 }
 793         self.scenario._access_topologies = ['topology1', 'topology3']
 794         self.scenario._core_topologies = ['topology2', 'topology4']
 795         self.scenario.create_traffic_model(mock_tp)
 796         mock_id_pairs.assert_called_once_with(mock_tp.full_profile)
 797         mock_obj_pairs.assert_called_once_with([])
 798         self.scenario.client.create_ipv4_traffic_model.assert_called_once_with(
 799             uplink_topologies, downlink_topologies)
 800
 801     def test__get_endpoints_src_dst_id_pairs(self):
 802         full_tp = OrderedDict([
 803             ('uplink_0', {'ipv4': {'port': 'xe0'}}),
 804             ('downlink_0', {'ipv4': {'port': 'xe1'}}),
 805             ('uplink_1', {'ipv4': {'port': 'xe0'}}),
 806             ('downlink_1', {'ipv4': {'port': 'xe3'}})])
 807         endpoints_src_dst_pairs = ['xe0', 'xe1', 'xe0', 'xe3']
 808         res = self.scenario._get_endpoints_src_dst_id_pairs(full_tp)
 809         self.assertEqual(res, endpoints_src_dst_pairs)
 810
 811     def test__get_endpoints_src_dst_id_pairs_wrong_flows_number(self):
 812         full_tp = OrderedDict([
 813             ('uplink_0', {'ipv4': {'port': 'xe0'}}),
 814             ('downlink_0', {'ipv4': {'port': 'xe1'}}),
 815             ('uplink_1', {'ipv4': {'port': 'xe0'}})])
 816         with self.assertRaises(RuntimeError):
 817             self.scenario._get_endpoints_src_dst_id_pairs(full_tp)
 818
 819     def test__get_endpoints_src_dst_id_pairs_no_port_key(self):
 820         full_tp = OrderedDict([
 821             ('uplink_0', {'ipv4': {'id': 1}}),
 822             ('downlink_0', {'ipv4': {'id': 2}})])
 823         self.assertEqual(
 824             self.scenario._get_endpoints_src_dst_id_pairs(full_tp), [])
 825
 826     def test__get_endpoints_src_dst_obj_pairs_tp_with_port_key(self):
 827         endpoints_id_pairs = ['xe0', 'xe1',
 828                               'xe0', 'xe1',
 829                               'xe0', 'xe3',
 830                               'xe0', 'xe3']
 831         ixia_cfg = {
 832             'pppoe_client': {
 833                 'sessions_per_port': 4,
 834                 'sessions_per_svlan': 1
 835             },
 836             'flow': {
 837                 'src_ip': [{'tg__0': 'xe0'}, {'tg__0': 'xe2'}],
 838                 'dst_ip': [{'tg__0': 'xe1'}, {'tg__0': 'xe3'}]
 839             }
 840         }
 841
 842         expected_result = ['tp1_dg1', 'tp3_dg1', 'tp1_dg2', 'tp3_dg1',
 843                            'tp1_dg3', 'tp4_dg1', 'tp1_dg4', 'tp4_dg1']
 844
 845         self.scenario._ixia_cfg = ixia_cfg
 846         self.scenario._access_topologies = ['topology1', 'topology2']
 847         self.scenario._core_topologies = ['topology3', 'topology4']
 848         self.mock_IxNextgen.get_topology_device_groups.side_effect = \
 849             [['tp1_dg1', 'tp1_dg2', 'tp1_dg3', 'tp1_dg4'],
 850              ['tp2_dg1', 'tp2_dg2', 'tp2_dg3', 'tp2_dg4'],
 851              ['tp3_dg1'],
 852              ['tp4_dg1']]
 853         res = self.scenario._get_endpoints_src_dst_obj_pairs(
 854             endpoints_id_pairs)
 855         self.assertEqual(res, expected_result)
 856
 857     def test__get_endpoints_src_dst_obj_pairs_default_flows_mapping(self):
 858         endpoints_id_pairs = []
 859         ixia_cfg = {
 860             'pppoe_client': {
 861                 'sessions_per_port': 4,
 862                 'sessions_per_svlan': 1
 863             },
 864             'flow': {
 865                 'src_ip': [{'tg__0': 'xe0'}, {'tg__0': 'xe2'}],
 866                 'dst_ip': [{'tg__0': 'xe1'}, {'tg__0': 'xe3'}]
 867             }
 868         }
 869
 870         self.scenario._ixia_cfg = ixia_cfg
 871         res = self.scenario._get_endpoints_src_dst_obj_pairs(
 872             endpoints_id_pairs)
 873         self.assertEqual(res, [])
 874
 875     def test_run_protocols(self):
 876         self.scenario.client.is_protocols_running.return_value = True
 877         self.scenario.run_protocols()
 878         self.scenario.client.start_protocols.assert_called_once()
 879
 880     def test_run_protocols_timeout_exception(self):
 881         self.scenario.client.is_protocols_running.return_value = False
 882         with self.assertRaises(exceptions.WaitTimeout):
 883             self.scenario.run_protocols()
 884         self.scenario.client.start_protocols.assert_called_once()
 885
 886     def test_stop_protocols(self):
 887         self.scenario.stop_protocols()
 888         self.scenario.client.stop_protocols.assert_called_once()
 889
 890     def test__get_intf_addr_str_type_input(self):
 891         intf = '192.168.10.2/24'
 892         ip, mask = self.scenario._get_intf_addr(intf)
 893         self.assertEqual(ip, '192.168.10.2')
 894         self.assertEqual(mask, 24)
 895
 896     def test__get_intf_addr_dict_type_input(self):
 897         intf = {'tg__0': 'xe0'}
 898         ip, mask = self.scenario._get_intf_addr(intf)
 899         self.assertEqual(ip, '10.1.1.1')
 900         self.assertEqual(mask, 24)
 901
 902     @mock.patch.object(tg_rfc2544_ixia.IxiaPppoeClientScenario, '_get_intf_addr')
 903     def test__fill_ixia_config(self, mock_get_intf_addr):
 904
 905         ixia_cfg = {
 906             'pppoe_client': {
 907                 'sessions_per_port': 4,
 908                 'sessions_per_svlan': 1,
 909                 's_vlan': 10,
 910                 'c_vlan': 20,
 911                 'ip': ['10.3.3.1/24', '10.4.4.1/24']
 912             },
 913             'ipv4_client': {
 914                 'sessions_per_port': 1,
 915                 'sessions_per_vlan': 1,
 916                 'vlan': 101,
 917                 'gateway_ip': ['10.1.1.1/24', '10.2.2.1/24'],
 918                 'ip': ['10.1.1.1/24', '10.2.2.1/24']
 919             }
 920         }
 921
 922         mock_get_intf_addr.side_effect = [
 923             ('10.3.3.1', '24'),
 924             ('10.4.4.1', '24'),
 925             ('10.1.1.1', '24'),
 926             ('10.2.2.1', '24'),
 927             ('10.1.1.1', '24'),
 928             ('10.2.2.1', '24')
 929         ]
 930         self.scenario._ixia_cfg = ixia_cfg
 931         self.scenario._fill_ixia_config()
 932         self.assertEqual(mock_get_intf_addr.call_count, 6)
 933         self.assertEqual(self.scenario._ixia_cfg['pppoe_client']['ip'],
 934                          ['10.3.3.1', '10.4.4.1'])
 935         self.assertEqual(self.scenario._ixia_cfg['ipv4_client']['ip'],
 936                          ['10.1.1.1', '10.2.2.1'])
 937         self.assertEqual(self.scenario._ixia_cfg['ipv4_client']['prefix'],
 938                          ['24', '24'])
 939
 940     @mock.patch('yardstick.network_services.libs.ixia_libs.ixnet.ixnet_api.Vlan')
 941     def test__apply_access_network_config_pap_auth(self, mock_vlan):
 942         _ixia_cfg = {
 943             'pppoe_client': {
 944                 'sessions_per_port': 4,
 945                 'sessions_per_svlan': 1,
 946                 's_vlan': 10,
 947                 'c_vlan': 20,
 948                 'pap_user': 'test_pap',
 949                 'pap_password': 'pap'
 950                 }}
 951         pap_user = _ixia_cfg['pppoe_client']['pap_user']
 952         pap_passwd = _ixia_cfg['pppoe_client']['pap_password']
 953         self.scenario._ixia_cfg = _ixia_cfg
 954         self.scenario._uplink_vports = [0, 2]
 955         self.scenario.client.add_topology.side_effect = ['Topology 1', 'Topology 2']
 956         self.scenario.client.add_device_group.side_effect = ['Dg1', 'Dg2', 'Dg3',
 957                                                              'Dg4', 'Dg5', 'Dg6',
 958                                                              'Dg7', 'Dg8']
 959         self.scenario.client.add_ethernet.side_effect = ['Eth1', 'Eth2', 'Eth3',
 960                                                          'Eth4', 'Eth5', 'Eth6',
 961                                                          'Eth7', 'Eth8']
 962         self.scenario._apply_access_network_config()
 963         self.assertEqual(self.scenario.client.add_topology.call_count, 2)
 964         self.assertEqual(self.scenario.client.add_device_group.call_count, 8)
 965         self.assertEqual(self.scenario.client.add_ethernet.call_count, 8)
 966         self.assertEqual(mock_vlan.call_count, 16)
 967         self.assertEqual(self.scenario.client.add_vlans.call_count, 8)
 968         self.assertEqual(self.scenario.client.add_pppox_client.call_count, 8)
 969         self.scenario.client.add_topology.assert_has_calls([
 970             mock.call('Topology access 0', 0),
 971             mock.call('Topology access 1', 2)
 972         ])
 973         self.scenario.client.add_device_group.assert_has_calls([
 974             mock.call('Topology 1', 'SVLAN 10', 1),
 975             mock.call('Topology 1', 'SVLAN 11', 1),
 976             mock.call('Topology 1', 'SVLAN 12', 1),
 977             mock.call('Topology 1', 'SVLAN 13', 1),
 978             mock.call('Topology 2', 'SVLAN 14', 1),
 979             mock.call('Topology 2', 'SVLAN 15', 1),
 980             mock.call('Topology 2', 'SVLAN 16', 1),
 981             mock.call('Topology 2', 'SVLAN 17', 1)
 982         ])
 983         self.scenario.client.add_ethernet.assert_has_calls([
 984             mock.call('Dg1', 'Ethernet'),
 985             mock.call('Dg2', 'Ethernet'),
 986             mock.call('Dg3', 'Ethernet'),
 987             mock.call('Dg4', 'Ethernet'),
 988             mock.call('Dg5', 'Ethernet'),
 989             mock.call('Dg6', 'Ethernet'),
 990             mock.call('Dg7', 'Ethernet'),
 991             mock.call('Dg8', 'Ethernet')
 992         ])
 993         mock_vlan.assert_has_calls([
 994             mock.call(vlan_id=10),
 995             mock.call(vlan_id=20, vlan_id_step=1),
 996             mock.call(vlan_id=11),
 997             mock.call(vlan_id=20, vlan_id_step=1),
 998             mock.call(vlan_id=12),
 999             mock.call(vlan_id=20, vlan_id_step=1),
1000             mock.call(vlan_id=13),
1001             mock.call(vlan_id=20, vlan_id_step=1),
1002             mock.call(vlan_id=14),
1003             mock.call(vlan_id=20, vlan_id_step=1),
1004             mock.call(vlan_id=15),
1005             mock.call(vlan_id=20, vlan_id_step=1),
1006             mock.call(vlan_id=16),
1007             mock.call(vlan_id=20, vlan_id_step=1),
1008             mock.call(vlan_id=17),
1009             mock.call(vlan_id=20, vlan_id_step=1)
1010         ])
1011         self.scenario.client.add_pppox_client.assert_has_calls([
1012             mock.call('Eth1', 'pap', pap_user, pap_passwd),
1013             mock.call('Eth2', 'pap', pap_user, pap_passwd),
1014             mock.call('Eth3', 'pap', pap_user, pap_passwd),
1015             mock.call('Eth4', 'pap', pap_user, pap_passwd),
1016             mock.call('Eth5', 'pap', pap_user, pap_passwd),
1017             mock.call('Eth6', 'pap', pap_user, pap_passwd),
1018             mock.call('Eth7', 'pap', pap_user, pap_passwd),
1019             mock.call('Eth8', 'pap', pap_user, pap_passwd)
1020         ])
1021
1022     def test__apply_access_network_config_chap_auth(self):
1023         _ixia_cfg = {
1024             'pppoe_client': {
1025                 'sessions_per_port': 4,
1026                 'sessions_per_svlan': 1,
1027                 's_vlan': 10,
1028                 'c_vlan': 20,
1029                 'chap_user': 'test_chap',
1030                 'chap_password': 'chap'
1031             }}
1032         chap_user = _ixia_cfg['pppoe_client']['chap_user']
1033         chap_passwd = _ixia_cfg['pppoe_client']['chap_password']
1034         self.scenario._ixia_cfg = _ixia_cfg
1035         self.scenario._uplink_vports = [0, 2]
1036         self.scenario.client.add_ethernet.side_effect = ['Eth1', 'Eth2', 'Eth3',
1037                                                          'Eth4', 'Eth5', 'Eth6',
1038                                                          'Eth7', 'Eth8']
1039         self.scenario._apply_access_network_config()
1040         self.assertEqual(self.scenario.client.add_pppox_client.call_count, 8)
1041         self.scenario.client.add_pppox_client.assert_has_calls([
1042             mock.call('Eth1', 'chap', chap_user, chap_passwd),
1043             mock.call('Eth2', 'chap', chap_user, chap_passwd),
1044             mock.call('Eth3', 'chap', chap_user, chap_passwd),
1045             mock.call('Eth4', 'chap', chap_user, chap_passwd),
1046             mock.call('Eth5', 'chap', chap_user, chap_passwd),
1047             mock.call('Eth6', 'chap', chap_user, chap_passwd),
1048             mock.call('Eth7', 'chap', chap_user, chap_passwd),
1049             mock.call('Eth8', 'chap', chap_user, chap_passwd)
1050         ])
1051
1052     @mock.patch('yardstick.network_services.libs.ixia_libs.ixnet.ixnet_api.Vlan')
1053     def test__apply_core_network_config_no_bgp_proto(self, mock_vlan):
1054         self.scenario._downlink_vports = [1, 3]
1055         self.scenario.client.add_topology.side_effect = ['Topology 1', 'Topology 2']
1056         self.scenario.client.add_device_group.side_effect = ['Dg1', 'Dg2']
1057         self.scenario.client.add_ethernet.side_effect = ['Eth1', 'Eth2']
1058         self.scenario._apply_core_network_config()
1059         self.assertEqual(self.scenario.client.add_topology.call_count, 2)
1060         self.assertEqual(self.scenario.client.add_device_group.call_count, 2)
1061         self.assertEqual(self.scenario.client.add_ethernet.call_count, 2)
1062         self.assertEqual(mock_vlan.call_count, 2)
1063         self.assertEqual(self.scenario.client.add_vlans.call_count, 2)
1064         self.assertEqual(self.scenario.client.add_ipv4.call_count, 2)
1065         self.scenario.client.add_topology.assert_has_calls([
1066             mock.call('Topology core 0', 1),
1067             mock.call('Topology core 1', 3)
1068         ])
1069         self.scenario.client.add_device_group.assert_has_calls([
1070             mock.call('Topology 1', 'Core port 0', 1),
1071             mock.call('Topology 2', 'Core port 1', 1)
1072         ])
1073         self.scenario.client.add_ethernet.assert_has_calls([
1074             mock.call('Dg1', 'Ethernet'),
1075             mock.call('Dg2', 'Ethernet')
1076         ])
1077         mock_vlan.assert_has_calls([
1078             mock.call(vlan_id=101),
1079             mock.call(vlan_id=102)
1080         ])
1081         self.scenario.client.add_ipv4.assert_has_calls([
1082             mock.call('Eth1', name='ipv4', addr=ipaddress.IPv4Address('10.1.1.2'),
1083                       addr_step='0.0.0.1', prefix='24', gateway='10.1.1.1'),
1084             mock.call('Eth2', name='ipv4', addr=ipaddress.IPv4Address('10.2.2.2'),
1085                       addr_step='0.0.0.1', prefix='24', gateway='10.2.2.1')
1086         ])
1087         self.scenario.client.add_bgp.assert_not_called()
1088
1089     def test__apply_core_network_config_with_bgp_proto(self):
1090         bgp_params = {
1091             'bgp': {
1092                 'bgp_type': 'external',
1093                 'dut_ip': '10.0.0.1',
1094                 'as_number': 65000
1095             }
1096         }
1097         self.scenario._ixia_cfg['ipv4_client'].update(bgp_params)
1098         self.scenario._downlink_vports = [1, 3]
1099         self.scenario.client.add_ipv4.side_effect = ['ipv4_1', 'ipv4_2']
1100         self.scenario._apply_core_network_config()
1101         self.assertEqual(self.scenario.client.add_bgp.call_count, 2)
1102         self.scenario.client.add_bgp.assert_has_calls([
1103             mock.call('ipv4_1', dut_ip=bgp_params["bgp"]["dut_ip"],
1104                       local_as=bgp_params["bgp"]["as_number"],
1105                       bgp_type=bgp_params["bgp"]["bgp_type"]),
1106             mock.call('ipv4_2', dut_ip=bgp_params["bgp"]["dut_ip"],
1107                       local_as=bgp_params["bgp"]["as_number"],
1108                       bgp_type=bgp_params["bgp"]["bgp_type"])
1109         ])
1110
1111     def test_update_tracking_options_raw_priority(self):
1112         raw_priority = {'raw': 4}
1113         self.scenario._ixia_cfg['priority'] = raw_priority
1114         self.scenario.update_tracking_options()
1115         self.scenario.client.set_flow_tracking.assert_called_once_with(
1116             ['flowGroup0', 'vlanVlanId0', 'ipv4Raw0'])
1117
1118     def test_update_tracking_options_tos_priority(self):
1119         tos_priority = {'tos': {'precedence': [4, 7]}}
1120         self.scenario._ixia_cfg['priority'] = tos_priority
1121         self.scenario.update_tracking_options()
1122         self.scenario.client.set_flow_tracking.assert_called_once_with(
1123             ['flowGroup0', 'vlanVlanId0', 'ipv4Precedence0'])
1124
1125     def test_update_tracking_options_dscp_priority(self):
1126         dscp_priority = {'dscp': {'defaultPHB': [4, 7]}}
1127         self.scenario._ixia_cfg['priority'] = dscp_priority
1128         self.scenario.update_tracking_options()
1129         self.scenario.client.set_flow_tracking.assert_called_once_with(
1130             ['flowGroup0', 'vlanVlanId0', 'ipv4DefaultPhb0'])
1131
1132     def test_update_tracking_options_invalid_priority_data(self):
1133         invalid_priority = {'tos': {'inet-precedence': [4, 7]}}
1134         self.scenario._ixia_cfg['priority'] = invalid_priority
1135         self.scenario.update_tracking_options()
1136         self.scenario.client.set_flow_tracking.assert_called_once_with(
1137             ['flowGroup0', 'vlanVlanId0', 'ipv4Precedence0'])
1138
1139     def test_get_tc_rfc2544_options(self):
1140         rfc2544_tc_opts = {'allowed_drop_rate': '0.0001 - 0.0001'}
1141         self.scenario._ixia_cfg['rfc2544'] = rfc2544_tc_opts
1142         res = self.scenario.get_tc_rfc2544_options()
1143         self.assertEqual(res, rfc2544_tc_opts)
1144
1145     def test__get_stats(self):
1146         self.scenario._get_stats()
1147         self.scenario.client.get_pppoe_scenario_statistics.assert_called_once()
1148
1149     def test_get_flow_id_data(self):
1150         stats = [{'id': 1, 'in_packets': 10, 'out_packets': 20}]
1151         key = "in_packets"
1152         flow_id = 1
1153         res = self.scenario.get_flow_id_data(stats, flow_id, key)
1154         self.assertEqual(res, 10)
1155
1156     @mock.patch.object(tg_rfc2544_ixia.IxiaPppoeClientScenario, '_get_stats')
1157     @mock.patch.object(tg_rfc2544_ixia.IxiaPppoeClientScenario,
1158                        'get_priority_flows_stats')
1159     def test_generate_samples(self, mock_prio_flow_statistics,
1160                               mock_get_stats):
1161         ixia_stats = {
1162             'flow_statistic': [
1163                 {'Flow_Group': 'RFC2544-1 - Flow Group 0001',
1164                  'Frames_Delta': '0',
1165                  'IP_Priority': '0',
1166                  'Rx_Frames': '3000',
1167                  'Tx_Frames': '3000',
1168                  'VLAN-ID': '100',
1169                  'Tx_Port': 'Ethernet - 001',
1170                  'Store-Forward_Avg_latency_ns': '2',
1171                  'Store-Forward_Min_latency_ns': '2',
1172                  'Store-Forward_Max_latency_ns': '2'},
1173                 {'Flow_Group': 'RFC2544-2 - Flow Group 0001',
1174                  'Frames_Delta': '0',
1175                  'IP_Priority': '0',
1176                  'Rx_Frames': '3000',
1177                  'Tx_Frames': '3000',
1178                  'VLAN-ID': '101',
1179                  'Tx_Port': 'Ethernet - 002',
1180                  'Store-Forward_Avg_latency_ns': '2',
1181                  'Store-Forward_Min_latency_ns': '2',
1182                  'Store-Forward_Max_latency_ns': '2'
1183                  }],
1184             'port_statistics': [
1185                 {'Frames_Tx': '3000',
1186                  'Valid_Frames_Rx': '3000',
1187                  'Bytes_Rx': '192000',
1188                  'Bytes_Tx': '192000',
1189                  'Rx_Rate_Kbps': '0.0',
1190                  'Tx_Rate_Kbps': '0.0',
1191                  'Rx_Rate_Mbps': '0.0',
1192                  'Tx_Rate_Mbps': '0.0',
1193                  'port_name': 'Ethernet - 001'},
1194                 {'Frames_Tx': '3000',
1195                  'Valid_Frames_Rx': '3000',
1196                  'Bytes_Rx': '192000',
1197                  'Bytes_Tx': '192000',
1198                  'Rx_Rate_Kbps': '0.0',
1199                  'Tx_Rate_Kbps': '0.0',
1200                  'Rx_Rate_Mbps': '0.0',
1201                  'Tx_Rate_Mbps': '0.0',
1202                  'port_name': 'Ethernet - 002'}],
1203             'pppox_client_per_port': [
1204                 {'Sessions_Down': '0',
1205                  'Sessions_Not_Started': '0',
1206                  'Sessions_Total': '1',
1207                  'Sessions_Up': '1',
1208                  'subs_port': 'Ethernet - 001'}]}
1209
1210         prio_flows_stats = {
1211             '0': {
1212                 'in_packets': 6000,
1213                 'out_packets': 6000,
1214                 'RxThroughput': 200.0,
1215                 'TxThroughput': 200.0,
1216                 'avg_latency_ns': 2,
1217                 'max_latency_ns': 2,
1218                 'min_latency_ns': 2
1219             }
1220         }
1221
1222         expected_result = {'priority_stats': {
1223             '0': {'RxThroughput': 200.0,
1224                   'TxThroughput': 200.0,
1225                   'avg_latency_ns': 2,
1226                   'max_latency_ns': 2,
1227                   'min_latency_ns': 2,
1228                   'in_packets': 6000,
1229                   'out_packets': 6000}},
1230             'xe0': {'RxThroughput': 100.0,
1231                     'Store-Forward_Avg_latency_ns': 2,
1232                     'Store-Forward_Max_latency_ns': 2,
1233                     'Store-Forward_Min_latency_ns': 2,
1234                     'TxThroughput': 100.0,
1235                     'in_packets': 3000,
1236                     'out_packets': 3000,
1237                     'in_bytes': 192000,
1238                     'out_bytes': 192000,
1239                     'RxThroughputBps': 6400.0,
1240                     'TxThroughputBps': 6400.0,
1241                     'rx_throughput_kps': 0.0,
1242                     'rx_throughput_mbps': 0.0,
1243                     'sessions_down': 0,
1244                     'sessions_not_started': 0,
1245                     'sessions_total': 1,
1246                     'sessions_up': 1,
1247                     'tx_throughput_kps': 0.0,
1248                     'tx_throughput_mbps': 0.0},
1249             'xe1': {'RxThroughput': 100.0,
1250                     'Store-Forward_Avg_latency_ns': 2,
1251                     'Store-Forward_Max_latency_ns': 2,
1252                     'Store-Forward_Min_latency_ns': 2,
1253                     'TxThroughput': 100.0,
1254                     'in_packets': 3000,
1255                     'out_packets': 3000,
1256                     'in_bytes': 192000,
1257                     'out_bytes': 192000,
1258                     'RxThroughputBps': 6400.0,
1259                     'TxThroughputBps': 6400.0,
1260                     'rx_throughput_kps': 0.0,
1261                     'rx_throughput_mbps': 0.0,
1262                     'tx_throughput_kps': 0.0,
1263                     'tx_throughput_mbps': 0.0}}
1264
1265         mock_get_stats.return_value = ixia_stats
1266         mock_prio_flow_statistics.return_value = prio_flows_stats
1267         ports = [0, 1]
1268         port_names = [{'name': 'xe0'}, {'name': 'xe1'}]
1269         duration = 30
1270         res_helper = mock.Mock()
1271         res_helper.vnfd_helper.find_interface_by_port.side_effect = \
1272             port_names
1273         samples = self.scenario.generate_samples(res_helper, ports, duration)
1274         self.assertIsNotNone(samples)
1275         self.assertIsNotNone(samples.get('xe0'))
1276         self.assertIsNotNone(samples.get('xe1'))
1277         self.assertEqual(samples, expected_result)
1278         mock_get_stats.assert_called_once()
1279         mock_prio_flow_statistics.assert_called_once()