yardstick/tests/unit/network_services/libs/ixia_libs/test_ixnet_api.py

   1 # Copyright (c) 2018 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 mock
  16 import IxNetwork
  17 import unittest
  18
  19 from copy import deepcopy
  20
  21 from yardstick.common import exceptions
  22 from yardstick.network_services.libs.ixia_libs.ixnet import ixnet_api
  23
  24
  25 UPLINK = 'uplink'
  26 DOWNLINK = 'downlink'
  27
  28 TRAFFIC_PARAMETERS = {
  29     UPLINK: {
  30         'id': 1,
  31         'bidir': 'False',
  32         'duration': 60,
  33         'rate': 10000.5,
  34         'rate_unit': 'fps',
  35         'outer_l2': {
  36             'framesize': {'64B': '25', '256B': '75'},
  37             'QinQ': None
  38         },
  39         'outer_l3': {
  40             'count': 512,
  41             'srcseed': 10,
  42             'dstseed': 20,
  43             'dscp': 0,
  44             'proto': 'udp',
  45             'ttl': 32,
  46             'dstip': '152.16.40.20',
  47             'srcip': '152.16.100.20',
  48             'dstmask': 24,
  49             'srcmask': 24
  50         },
  51         'outer_l4': {
  52             'seed': 1,
  53             'count': 1,
  54             'dstport': 2001,
  55             'srcport': 1234,
  56             'srcportmask': 0,
  57             'dstportmask': 0
  58         },
  59         'traffic_type': 'continuous'
  60     },
  61     DOWNLINK: {
  62         'id': 2,
  63         'bidir': 'False',
  64         'duration': 60,
  65         'rate': 75.2,
  66         'rate_unit': '%',
  67         'outer_l2': {
  68             'framesize': {'128B': '35', '1024B': '65'},
  69             'QinQ': None
  70         },
  71         'outer_l3': {
  72             'count': 1024,
  73             'srcseed': 30,
  74             'dstseed': 40,
  75             'dscp': 0,
  76             'proto': 'udp',
  77             'ttl': 32,
  78             'dstip': '2001::10',
  79             'srcip': '2021::10',
  80             'dstmask': 64,
  81             'srcmask': 64
  82         },
  83         'outer_l4': {
  84             'seed': 1,
  85             'count': 1,
  86             'dstport': 1234,
  87             'srcport': 2001,
  88             'srcportmask': 0,
  89             'dstportmask': 0
  90         },
  91         'traffic_type': 'continuous'
  92     }
  93 }
  94
  95
  96 class TestIxNextgen(unittest.TestCase):
  97
  98     def setUp(self):
  99         self.ixnet = mock.Mock()
 100         self.ixnet.execute = mock.Mock()
 101         self.ixnet.getRoot.return_value = 'my_root'
 102         self.ixnet_gen = ixnet_api.IxNextgen()
 103         self.ixnet_gen._ixnet = self.ixnet
 104
 105     def test_get_config(self):
 106         tg_cfg = {
 107             'vdu': [
 108                 {
 109                     'external-interface': [
 110                         {'virtual-interface': {'vpci': '0000:07:00.1'}},
 111                         {'virtual-interface': {'vpci': '0001:08:01.2'}}
 112                     ]
 113                 },
 114             ],
 115             'mgmt-interface': {
 116                 'ip': 'test1',
 117                 'tg-config': {
 118                     'dut_result_dir': 'test2',
 119                     'version': 'test3',
 120                     'ixchassis': 'test4',
 121                     'tcl_port': 'test5',
 122                 },
 123             }
 124         }
 125
 126         expected = {
 127             'machine': 'test1',
 128             'port': 'test5',
 129             'chassis': 'test4',
 130             'cards': ['0000', '0001'],
 131             'ports': ['07', '08'],
 132             'output_dir': 'test2',
 133             'version': 'test3',
 134             'bidir': True,
 135         }
 136
 137         result = ixnet_api.IxNextgen.get_config(tg_cfg)
 138         self.assertEqual(result, expected)
 139
 140     def test__get_config_element_by_flow_group_name(self):
 141         self.ixnet_gen._ixnet.getList.side_effect = [['traffic_item'],
 142                                                      ['fg_01']]
 143         self.ixnet_gen._ixnet.getAttribute.return_value = 'flow_group_01'
 144         output = self.ixnet_gen._get_config_element_by_flow_group_name(
 145             'flow_group_01')
 146         self.assertEqual('traffic_item/configElement:flow_group_01', output)
 147
 148     def test__get_config_element_by_flow_group_name_no_match(self):
 149         self.ixnet_gen._ixnet.getList.side_effect = [['traffic_item'],
 150                                                      ['fg_01']]
 151         self.ixnet_gen._ixnet.getAttribute.return_value = 'flow_group_02'
 152         output = self.ixnet_gen._get_config_element_by_flow_group_name(
 153             'flow_group_01')
 154         self.assertIsNone(output)
 155
 156     def test__get_stack_item(self):
 157         self.ixnet_gen._ixnet.getList.return_value = ['tcp1', 'tcp2', 'udp']
 158         with mock.patch.object(
 159                 self.ixnet_gen, '_get_config_element_by_flow_group_name') as \
 160                 mock_get_cfg_element:
 161             mock_get_cfg_element.return_value = 'cfg_element'
 162             output = self.ixnet_gen._get_stack_item(mock.ANY, ixnet_api.PROTO_TCP)
 163         self.assertEqual(['tcp1', 'tcp2'], output)
 164
 165     def test__get_stack_item_no_config_element(self):
 166         with mock.patch.object(
 167                 self.ixnet_gen, '_get_config_element_by_flow_group_name',
 168                 return_value=None):
 169             with self.assertRaises(exceptions.IxNetworkFlowNotPresent):
 170                 self.ixnet_gen._get_stack_item(mock.ANY, mock.ANY)
 171
 172     def test__get_field_in_stack_item(self):
 173         self.ixnet_gen._ixnet.getList.return_value = ['field1', 'field2']
 174         output = self.ixnet_gen._get_field_in_stack_item(mock.ANY, 'field2')
 175         self.assertEqual('field2', output)
 176
 177     def test__get_field_in_stack_item_no_field_present(self):
 178         self.ixnet_gen._ixnet.getList.return_value = ['field1', 'field2']
 179         with self.assertRaises(exceptions.IxNetworkFieldNotPresentInStackItem):
 180             self.ixnet_gen._get_field_in_stack_item(mock.ANY, 'field3')
 181
 182     def test__parse_framesize(self):
 183         framesize = {'64B': '75', '512b': '25'}
 184         output = self.ixnet_gen._parse_framesize(framesize)
 185         self.assertEqual(2, len(output))
 186         self.assertIn([64, 64, 75], output)
 187         self.assertIn([512, 512, 25], output)
 188
 189     def test_add_topology(self):
 190         self.ixnet_gen.ixnet.add.return_value = 'obj'
 191         self.ixnet_gen.add_topology('topology 1', 'vports')
 192         self.ixnet_gen.ixnet.add.assert_called_once_with('my_root', 'topology')
 193         self.ixnet_gen.ixnet.setMultiAttribute.assert_called_once_with(
 194             'obj', '-name', 'topology 1', '-vports', 'vports')
 195         self.ixnet_gen.ixnet.commit.assert_called_once()
 196
 197     def test_add_device_group(self):
 198         self.ixnet_gen.ixnet.add.return_value = 'obj'
 199         self.ixnet_gen.add_device_group('topology', 'device group 1', '1')
 200         self.ixnet_gen.ixnet.add.assert_called_once_with('topology',
 201                                                          'deviceGroup')
 202         self.ixnet_gen.ixnet.setMultiAttribute.assert_called_once_with(
 203             'obj', '-name', 'device group 1', '-multiplier', '1')
 204         self.ixnet_gen.ixnet.commit.assert_called_once()
 205
 206     def test_add_ethernet(self):
 207         self.ixnet_gen.ixnet.add.return_value = 'obj'
 208         self.ixnet_gen.add_ethernet('device_group', 'ethernet 1')
 209         self.ixnet_gen.ixnet.add.assert_called_once_with('device_group',
 210                                                          'ethernet')
 211         self.ixnet_gen.ixnet.setMultiAttribute.assert_called_once_with(
 212             'obj', '-name', 'ethernet 1')
 213         self.ixnet_gen.ixnet.commit.assert_called_once()
 214
 215     def test_add_vlans_single(self):
 216         obj = 'ethernet'
 217         self.ixnet_gen.ixnet.getAttribute.return_value = 'attr'
 218         self.ixnet_gen.ixnet.getList.return_value = ['vlan1', 'vlan2']
 219         vlan1 = ixnet_api.Vlan(vlan_id=100, tp_id='ethertype88a8', prio=2)
 220         vlan2 = ixnet_api.Vlan(vlan_id=101, tp_id='ethertype88a8', prio=3)
 221         self.ixnet_gen.add_vlans(obj, [vlan1, vlan2])
 222         self.ixnet_gen.ixnet.setMultiAttribute.assert_any_call('ethernet',
 223                                                                '-vlanCount', 2)
 224         self.ixnet_gen.ixnet.setMultiAttribute.assert_any_call('attr/singleValue',
 225                                                                '-value', 100)
 226         self.ixnet_gen.ixnet.setMultiAttribute.assert_any_call('attr/singleValue',
 227                                                                '-value', 101)
 228         self.ixnet_gen.ixnet.setMultiAttribute.assert_any_call('attr/singleValue',
 229                                                                '-value', 2)
 230         self.ixnet_gen.ixnet.setMultiAttribute.assert_any_call('attr/singleValue',
 231                                                                '-value', 3)
 232         self.ixnet_gen.ixnet.setMultiAttribute.assert_any_call(
 233             'attr/singleValue', '-value', 'ethertype88a8')
 234         self.assertEqual(self.ixnet.commit.call_count, 2)
 235
 236     def test_add_vlans_increment(self):
 237         obj = 'ethernet'
 238         self.ixnet_gen.ixnet.add.return_value = 'obj'
 239         self.ixnet_gen.ixnet.getAttribute.return_value = 'attr'
 240         self.ixnet_gen.ixnet.getList.return_value = ['vlan1']
 241         vlan = ixnet_api.Vlan(vlan_id=100, vlan_id_step=1, prio=3, prio_step=2)
 242         self.ixnet_gen.add_vlans(obj, [vlan])
 243         self.ixnet.setMultiAttribute.assert_any_call('obj', '-start', 100,
 244                                                      '-step', 1,
 245                                                      '-direction', 'increment')
 246         self.ixnet.setMultiAttribute.assert_any_call('obj', '-start', 3,
 247                                                      '-step', 2,
 248                                                      '-direction', 'increment')
 249
 250         self.assertEqual(self.ixnet.commit.call_count, 2)
 251
 252     def test_add_vlans_invalid(self):
 253         vlans = []
 254         self.assertRaises(RuntimeError, self.ixnet_gen.add_vlans, 'obj', vlans)
 255
 256     def test_add_ipv4(self):
 257         self.ixnet_gen.ixnet.add.return_value = 'obj'
 258         self.ixnet_gen.add_ipv4('ethernet 1', name='ipv4 1')
 259         self.ixnet_gen.ixnet.add.assert_called_once_with('ethernet 1', 'ipv4')
 260         self.ixnet_gen.ixnet.setAttribute.assert_called_once_with('obj',
 261                                                                   '-name',
 262                                                                   'ipv4 1')
 263         self.assertEqual(self.ixnet.commit.call_count, 2)
 264
 265     def test_add_ipv4_single(self):
 266         self.ixnet_gen.ixnet.add.return_value = 'obj'
 267         self.ixnet_gen.ixnet.getAttribute.return_value = 'attr'
 268         self.ixnet_gen.add_ipv4('ethernet 1', name='ipv4 1', addr='100.1.1.100',
 269                                 prefix='24', gateway='100.1.1.200')
 270         self.ixnet_gen.ixnet.add.assert_called_once_with('ethernet 1', 'ipv4')
 271         self.ixnet_gen.ixnet.setAttribute.assert_called_once_with('obj',
 272                                                                   '-name',
 273                                                                   'ipv4 1')
 274         self.ixnet_gen.ixnet.setMultiAttribute.assert_any_call(
 275             'attr/singleValue', '-value', '100.1.1.100')
 276         self.ixnet_gen.ixnet.setMultiAttribute.assert_any_call(
 277             'attr/singleValue', '-value', '24')
 278         self.ixnet_gen.ixnet.setMultiAttribute.assert_any_call(
 279             'attr/singleValue', '-value', '100.1.1.200')
 280
 281         self.assertEqual(self.ixnet.commit.call_count, 2)
 282
 283     def test_add_ipv4_counter(self):
 284         self.ixnet_gen.ixnet.add.return_value = 'obj'
 285         self.ixnet_gen.ixnet.getAttribute.return_value = 'attr'
 286         self.ixnet_gen.add_ipv4('ethernet 1', name='ipv4 1',
 287                                 addr='100.1.1.100',
 288                                 addr_step='1',
 289                                 addr_direction='increment',
 290                                 prefix='24',
 291                                 gateway='100.1.1.200',
 292                                 gw_step='1',
 293                                 gw_direction='increment')
 294         self.ixnet_gen.ixnet.add.assert_any_call('ethernet 1', 'ipv4')
 295         self.ixnet_gen.ixnet.setAttribute.assert_called_once_with('obj',
 296                                                                   '-name',
 297                                                                   'ipv4 1')
 298         self.ixnet_gen.ixnet.add.assert_any_call('attr', 'counter')
 299         self.ixnet_gen.ixnet.setMultiAttribute.assert_any_call('obj', '-start',
 300                                                                '100.1.1.100',
 301                                                                '-step', '1',
 302                                                                '-direction',
 303                                                                'increment')
 304         self.ixnet_gen.ixnet.setMultiAttribute.assert_any_call(
 305             'attr/singleValue', '-value', '24')
 306         self.ixnet_gen.ixnet.setMultiAttribute.assert_any_call('obj', '-start',
 307                                                                '100.1.1.200',
 308                                                                '-step', '1',
 309                                                                '-direction',
 310                                                                'increment')
 311         self.assertEqual(self.ixnet.commit.call_count, 2)
 312
 313     def test_add_pppox_client(self):
 314         self.ixnet_gen.ixnet.add.return_value = 'obj'
 315         self.ixnet_gen.ixnet.getAttribute.return_value = 'attr'
 316         self.ixnet_gen.add_pppox_client('ethernet 1', 'pap', 'user', 'pwd')
 317         self.ixnet_gen.ixnet.add.assert_called_once_with('ethernet 1',
 318                                                          'pppoxclient')
 319
 320         self.ixnet_gen.ixnet.setMultiAttribute.assert_any_call(
 321             'attr/singleValue', '-value', 'pap')
 322         self.ixnet_gen.ixnet.setMultiAttribute.assert_any_call(
 323             'attr/singleValue', '-value', 'user')
 324         self.ixnet_gen.ixnet.setMultiAttribute.assert_any_call(
 325             'attr/singleValue', '-value', 'pwd')
 326
 327         self.assertEqual(self.ixnet.commit.call_count, 2)
 328
 329     def test_add_pppox_client_invalid_auth(self):
 330         self.ixnet_gen.ixnet.add.return_value = 'obj'
 331         self.ixnet_gen.ixnet.getAttribute.return_value = 'attr'
 332         self.assertRaises(NotImplementedError, self.ixnet_gen.add_pppox_client,
 333                           'ethernet 1', 'invalid_auth', 'user', 'pwd')
 334
 335         self.ixnet_gen.ixnet.setMultiAttribute.assert_not_called()
 336
 337     @mock.patch.object(IxNetwork, 'IxNet')
 338     def test_connect(self, mock_ixnet):
 339         mock_ixnet.return_value = self.ixnet
 340         with mock.patch.object(self.ixnet_gen, 'get_config') as mock_config:
 341             mock_config.return_value = {'machine': 'machine_fake',
 342                                         'port': 'port_fake',
 343                                         'version': 12345}
 344             self.ixnet_gen.connect(mock.ANY)
 345
 346         self.ixnet.connect.assert_called_once_with(
 347             'machine_fake', '-port', 'port_fake', '-version', '12345')
 348         mock_config.assert_called_once()
 349
 350     def test_connect_invalid_config_no_machine(self):
 351         self.ixnet_gen.get_config = mock.Mock(return_value={
 352             'port': 'port_fake',
 353             'version': '12345'})
 354         self.assertRaises(KeyError, self.ixnet_gen.connect, mock.ANY)
 355         self.ixnet.connect.assert_not_called()
 356
 357     def test_connect_invalid_config_no_port(self):
 358         self.ixnet_gen.get_config = mock.Mock(return_value={
 359             'machine': 'machine_fake',
 360             'version': '12345'})
 361         self.assertRaises(KeyError, self.ixnet_gen.connect, mock.ANY)
 362         self.ixnet.connect.assert_not_called()
 363
 364     def test_connect_invalid_config_no_version(self):
 365         self.ixnet_gen.get_config = mock.Mock(return_value={
 366             'machine': 'machine_fake',
 367             'port': 'port_fake'})
 368         self.assertRaises(KeyError, self.ixnet_gen.connect, mock.ANY)
 369         self.ixnet.connect.assert_not_called()
 370
 371     def test_connect_no_config(self):
 372         self.ixnet_gen.get_config = mock.Mock(return_value={})
 373         self.assertRaises(KeyError, self.ixnet_gen.connect, mock.ANY)
 374         self.ixnet.connect.assert_not_called()
 375
 376     def test_clear_config(self):
 377         self.ixnet_gen.clear_config()
 378         self.ixnet.execute.assert_called_once_with('newConfig')
 379
 380     @mock.patch.object(ixnet_api, 'log')
 381     def test_assign_ports_2_ports(self, *args):
 382         self.ixnet.getAttribute.side_effect = ['up', 'down']
 383         config = {
 384             'chassis': '1.1.1.1',
 385             'cards': ['1', '2'],
 386             'ports': ['2', '2']}
 387         self.ixnet_gen._cfg = config
 388
 389         self.assertIsNone(self.ixnet_gen.assign_ports())
 390         self.assertEqual(self.ixnet.execute.call_count, 1)
 391         self.assertEqual(self.ixnet.commit.call_count, 3)
 392         self.assertEqual(self.ixnet.getAttribute.call_count, 2)
 393
 394     @mock.patch.object(ixnet_api, 'log')
 395     def test_assign_ports_port_down(self, mock_log):
 396         self.ixnet.getAttribute.return_value = 'down'
 397         config = {
 398             'chassis': '1.1.1.1',
 399             'cards': ['1', '2'],
 400             'ports': ['3', '4']}
 401         self.ixnet_gen._cfg = config
 402         self.ixnet_gen.assign_ports()
 403         mock_log.warning.assert_called()
 404
 405     def test_assign_ports_no_config(self):
 406         self.ixnet_gen._cfg = {}
 407         self.assertRaises(KeyError, self.ixnet_gen.assign_ports)
 408
 409     def test__create_traffic_item(self):
 410         self.ixnet.add.return_value = 'my_new_traffic_item'
 411         self.ixnet.remapIds.return_value = ['my_traffic_item_id']
 412
 413         self.ixnet_gen._create_traffic_item()
 414         self.ixnet.add.assert_called_once_with(
 415             'my_root/traffic', 'trafficItem')
 416         self.ixnet.setMultiAttribute.assert_called_once_with(
 417             'my_new_traffic_item', '-name', 'RFC2544', '-trafficType', 'raw')
 418         self.assertEqual(2, self.ixnet.commit.call_count)
 419         self.ixnet.remapIds.assert_called_once_with('my_new_traffic_item')
 420         self.ixnet.setAttribute('my_traffic_item_id/tracking',
 421                                 '-trackBy', 'trafficGroupId0')
 422
 423     def test__create_flow_groups(self):
 424         uplink_endpoints = ['up_endp1', 'up_endp2']
 425         downlink_endpoints = ['down_endp1', 'down_endp2']
 426         self.ixnet_gen.ixnet.getList.side_effect = [['traffic_item'], ['1', '2']]
 427         self.ixnet_gen.ixnet.add.side_effect = ['endp1', 'endp2', 'endp3',
 428                                                 'endp4']
 429         self.ixnet_gen._create_flow_groups(uplink_endpoints, downlink_endpoints)
 430         self.ixnet_gen.ixnet.add.assert_has_calls([
 431             mock.call('traffic_item', 'endpointSet'),
 432             mock.call('traffic_item', 'endpointSet')])
 433         self.ixnet_gen.ixnet.setMultiAttribute.assert_has_calls([
 434             mock.call('endp1', '-name', '1', '-sources', ['up_endp1'],
 435                       '-destinations', ['down_endp1']),
 436             mock.call('endp2', '-name', '2', '-sources', ['down_endp1'],
 437                       '-destinations', ['up_endp1']),
 438             mock.call('endp3', '-name', '3', '-sources', ['up_endp2'],
 439                       '-destinations', ['down_endp2']),
 440             mock.call('endp4', '-name', '4', '-sources', ['down_endp2'],
 441                       '-destinations', ['up_endp2'])])
 442
 443     def test__append_protocol_to_stack(self):
 444
 445         self.ixnet_gen._append_procotol_to_stack('my_protocol', 'prev_element')
 446         self.ixnet.execute.assert_called_with(
 447             'append', 'prev_element',
 448             'my_root/traffic/protocolTemplate:"my_protocol"')
 449
 450     def test__setup_config_elements(self):
 451         self.ixnet_gen.ixnet.getList.side_effect = [['traffic_item'],
 452                                                ['cfg_element']]
 453         with mock.patch.object(self.ixnet_gen, '_append_procotol_to_stack') as \
 454                 mock_append_proto:
 455             self.ixnet_gen._setup_config_elements()
 456         mock_append_proto.assert_has_calls([
 457             mock.call(ixnet_api.PROTO_UDP, 'cfg_element/stack:"ethernet-1"'),
 458             mock.call(ixnet_api.PROTO_IPV4, 'cfg_element/stack:"ethernet-1"')])
 459         self.ixnet_gen.ixnet.setAttribute.assert_has_calls([
 460             mock.call('cfg_element/frameRateDistribution', '-portDistribution',
 461                       'splitRateEvenly'),
 462             mock.call('cfg_element/frameRateDistribution',
 463                       '-streamDistribution', 'splitRateEvenly')])
 464
 465     @mock.patch.object(ixnet_api.IxNextgen, '_create_traffic_item')
 466     @mock.patch.object(ixnet_api.IxNextgen, '_create_flow_groups')
 467     @mock.patch.object(ixnet_api.IxNextgen, '_setup_config_elements')
 468     def test_create_traffic_model(self, mock__setup_config_elements,
 469                                   mock__create_flow_groups,
 470                                   mock__create_traffic_item):
 471         uplink_ports = ['port1', 'port3']
 472         downlink_ports = ['port2', 'port4']
 473         uplink_endpoints = ['port1/protocols', 'port3/protocols']
 474         downlink_endpoints = ['port2/protocols', 'port4/protocols']
 475         self.ixnet_gen.create_traffic_model(uplink_ports, downlink_ports)
 476         mock__create_traffic_item.assert_called_once_with('raw')
 477         mock__create_flow_groups.assert_called_once_with(uplink_endpoints,
 478                                                          downlink_endpoints)
 479         mock__setup_config_elements.assert_called_once()
 480
 481     @mock.patch.object(ixnet_api.IxNextgen, '_create_traffic_item')
 482     @mock.patch.object(ixnet_api.IxNextgen, '_create_flow_groups')
 483     @mock.patch.object(ixnet_api.IxNextgen, '_setup_config_elements')
 484     def test_create_ipv4_traffic_model(self, mock__setup_config_elements,
 485                                        mock__create_flow_groups,
 486                                        mock__create_traffic_item):
 487         uplink_topologies = ['up1', 'up3']
 488         downlink_topologies = ['down2', 'down4']
 489         self.ixnet_gen.create_ipv4_traffic_model(uplink_topologies,
 490                                                  downlink_topologies)
 491         mock__create_traffic_item.assert_called_once_with('ipv4')
 492         mock__create_flow_groups.assert_called_once_with(uplink_topologies,
 493                                                          downlink_topologies)
 494         mock__setup_config_elements.assert_called_once_with(False)
 495
 496     def test__update_frame_mac(self):
 497         with mock.patch.object(self.ixnet_gen, '_get_field_in_stack_item') as \
 498                 mock_get_field:
 499             mock_get_field.return_value = 'field_descriptor'
 500             self.ixnet_gen._update_frame_mac('ethernet_descriptor', 'field', 'mac')
 501         mock_get_field.assert_called_once_with('ethernet_descriptor', 'field')
 502         self.ixnet_gen.ixnet.setMultiAttribute(
 503             'field_descriptor', '-singleValue', 'mac', '-fieldValue', 'mac',
 504             '-valueType', 'singleValue')
 505         self.ixnet_gen.ixnet.commit.assert_called_once()
 506
 507     def test_update_frame(self):
 508         with mock.patch.object(
 509                 self.ixnet_gen, '_get_config_element_by_flow_group_name',
 510                 return_value='cfg_element'), \
 511                 mock.patch.object(self.ixnet_gen, '_update_frame_mac') as \
 512                 mock_update_frame, \
 513                 mock.patch.object(self.ixnet_gen, '_get_stack_item') as \
 514                 mock_get_stack_item:
 515             mock_get_stack_item.side_effect = [['item1'], ['item2'],
 516                                                ['item3'], ['item4']]
 517             self.ixnet_gen.update_frame(TRAFFIC_PARAMETERS, 50)
 518
 519         self.assertEqual(6, len(self.ixnet_gen.ixnet.setMultiAttribute.mock_calls))
 520         self.assertEqual(4, len(mock_update_frame.mock_calls))
 521
 522         self.ixnet_gen.ixnet.setMultiAttribute.assert_has_calls([
 523             mock.call('cfg_element/transmissionControl',
 524                       '-type', 'continuous', '-duration', 50)
 525         ])
 526
 527     def test_update_frame_qinq(self):
 528         with mock.patch.object(self.ixnet_gen,
 529                                '_get_config_element_by_flow_group_name',
 530                                return_value='cfg_element'), \
 531              mock.patch.object(self.ixnet_gen, '_update_frame_mac'),\
 532              mock.patch.object(self.ixnet_gen, '_get_stack_item',
 533                                return_value='item'), \
 534              mock.patch.object(self.ixnet_gen, '_get_field_in_stack_item',
 535                                return_value='field'):
 536
 537             traffic_parameters = deepcopy(TRAFFIC_PARAMETERS)
 538             traffic_parameters[UPLINK]['outer_l2']['QinQ'] = {
 539                 'S-VLAN': {'id': 128,
 540                            'priority': 1,
 541                            'cfi': 0},
 542                 'C-VLAN': {'id': 512,
 543                            'priority': 0,
 544                            'cfi': 2}
 545             }
 546
 547             self.ixnet_gen.update_frame(traffic_parameters, 50)
 548
 549         self.ixnet_gen.ixnet.setMultiAttribute.assert_has_calls([
 550             mock.call('field', '-auto', 'false', '-singleValue', '0x88a8',
 551                       '-fieldValue', '0x88a8', '-valueType', 'singleValue'),
 552             mock.call('field', '-auto', 'false', '-singleValue', 1,
 553                       '-fieldValue', 1, '-valueType', 'singleValue'),
 554             mock.call('field', '-auto', 'false', '-singleValue', 128,
 555                       '-fieldValue', 128, '-valueType', 'singleValue'),
 556             mock.call('field', '-auto', 'false', '-singleValue', 512,
 557                       '-fieldValue', 512, '-valueType', 'singleValue'),
 558             mock.call('field', '-auto', 'false', '-singleValue', 2,
 559                       '-fieldValue', 2, '-valueType', 'singleValue')
 560         ], any_order=True)
 561
 562     def test_update_frame_flow_not_present(self):
 563         with mock.patch.object(
 564                 self.ixnet_gen, '_get_config_element_by_flow_group_name',
 565                 return_value=None):
 566             with self.assertRaises(exceptions.IxNetworkFlowNotPresent):
 567                 self.ixnet_gen.update_frame(TRAFFIC_PARAMETERS, 40)
 568
 569     def test_get_statistics(self):
 570         port_statistics = '::ixNet::OBJ-/statistics/view:"Port Statistics"'
 571         flow_statistics = '::ixNet::OBJ-/statistics/view:"Flow Statistics"'
 572         with mock.patch.object(self.ixnet_gen, '_build_stats_map') as \
 573                 mock_build_stats:
 574             self.ixnet_gen.get_statistics()
 575
 576         mock_build_stats.assert_has_calls([
 577             mock.call(port_statistics, self.ixnet_gen.PORT_STATS_NAME_MAP),
 578             mock.call(flow_statistics, self.ixnet_gen.LATENCY_NAME_MAP)])
 579
 580     def test__update_ipv4_address(self):
 581         with mock.patch.object(self.ixnet_gen, '_get_field_in_stack_item',
 582                                return_value='field_desc'):
 583             self.ixnet_gen._update_ipv4_address(mock.ANY, mock.ANY, '192.168.1.1',
 584                                            100, 26, 25)
 585         self.ixnet_gen.ixnet.setMultiAttribute.assert_called_once_with(
 586             'field_desc', '-seed', 100, '-fixedBits', '192.168.1.1',
 587             '-randomMask', '0.0.0.63', '-valueType', 'random',
 588             '-countValue', 25)
 589
 590     def test__update_udp_port(self):
 591         with mock.patch.object(self.ixnet_gen, '_get_field_in_stack_item',
 592                                return_value='field_desc'):
 593             self.ixnet_gen._update_udp_port(mock.ANY, mock.ANY, 1234,
 594                                             2, 0, 2)
 595
 596         self.ixnet_gen.ixnet.setMultiAttribute.assert_called_once_with(
 597             'field_desc',
 598             '-auto', 'false',
 599             '-seed', 1,
 600             '-fixedBits', 1234,
 601             '-randomMask', 0,
 602             '-valueType', 'random',
 603             '-countValue', 1)
 604
 605     def test_update_ip_packet(self):
 606         with mock.patch.object(self.ixnet_gen, '_update_ipv4_address') as \
 607                 mock_update_add, \
 608                 mock.patch.object(self.ixnet_gen, '_get_stack_item'), \
 609                 mock.patch.object(self.ixnet_gen,
 610                 '_get_config_element_by_flow_group_name', return_value='celm'):
 611             self.ixnet_gen.update_ip_packet(TRAFFIC_PARAMETERS)
 612
 613         self.assertEqual(4, len(mock_update_add.mock_calls))
 614
 615     def test_update_ip_packet_exception_no_config_element(self):
 616         with mock.patch.object(self.ixnet_gen,
 617                                '_get_config_element_by_flow_group_name',
 618                                return_value=None):
 619             with self.assertRaises(exceptions.IxNetworkFlowNotPresent):
 620                 self.ixnet_gen.update_ip_packet(TRAFFIC_PARAMETERS)
 621
 622     def test_update_l4(self):
 623         with mock.patch.object(self.ixnet_gen, '_update_udp_port') as \
 624                 mock_update_udp, \
 625                 mock.patch.object(self.ixnet_gen, '_get_stack_item'), \
 626                 mock.patch.object(self.ixnet_gen,
 627                 '_get_config_element_by_flow_group_name', return_value='celm'):
 628             self.ixnet_gen.update_l4(TRAFFIC_PARAMETERS)
 629
 630         self.assertEqual(4, len(mock_update_udp.mock_calls))
 631
 632     def test_update_l4_exception_no_config_element(self):
 633         with mock.patch.object(self.ixnet_gen,
 634                                '_get_config_element_by_flow_group_name',
 635                                return_value=None):
 636             with self.assertRaises(exceptions.IxNetworkFlowNotPresent):
 637                 self.ixnet_gen.update_l4(TRAFFIC_PARAMETERS)
 638
 639     def test_update_l4_exception_no_supported_proto(self):
 640         traffic_parameters = {
 641             UPLINK: {
 642                 'id': 1,
 643                 'outer_l3': {
 644                     'proto': 'unsupported',
 645                 },
 646             },
 647         }
 648         with mock.patch.object(self.ixnet_gen,
 649                                '_get_config_element_by_flow_group_name',
 650                                return_value='celm'):
 651             with self.assertRaises(exceptions.IXIAUnsupportedProtocol):
 652                 self.ixnet_gen.update_l4(traffic_parameters)
 653
 654     @mock.patch.object(ixnet_api.IxNextgen, '_get_traffic_state')
 655     def test_start_traffic(self, mock_ixnextgen_get_traffic_state):
 656         self.ixnet_gen._ixnet.getList.return_value = [0]
 657
 658         mock_ixnextgen_get_traffic_state.side_effect = [
 659             'stopped', 'started', 'started', 'started']
 660
 661         result = self.ixnet_gen.start_traffic()
 662         self.assertIsNone(result)
 663         self.ixnet.getList.assert_called_once()
 664         self.assertEqual(3, self.ixnet_gen._ixnet.execute.call_count)
 665
 666     @mock.patch.object(ixnet_api.IxNextgen, '_get_traffic_state')
 667     def test_start_traffic_traffic_running(
 668             self, mock_ixnextgen_get_traffic_state):
 669         self.ixnet_gen._ixnet.getList.return_value = [0]
 670         mock_ixnextgen_get_traffic_state.side_effect = [
 671             'started', 'stopped', 'started']
 672
 673         result = self.ixnet_gen.start_traffic()
 674         self.assertIsNone(result)
 675         self.ixnet.getList.assert_called_once()
 676         self.assertEqual(4, self.ixnet_gen._ixnet.execute.call_count)
 677
 678     @mock.patch.object(ixnet_api.IxNextgen, '_get_traffic_state')
 679     def test_start_traffic_wait_for_traffic_to_stop(
 680             self, mock_ixnextgen_get_traffic_state):
 681         self.ixnet_gen._ixnet.getList.return_value = [0]
 682         mock_ixnextgen_get_traffic_state.side_effect = [
 683             'started', 'started', 'started', 'stopped', 'started']
 684
 685         result = self.ixnet_gen.start_traffic()
 686         self.assertIsNone(result)
 687         self.ixnet.getList.assert_called_once()
 688         self.assertEqual(4, self.ixnet_gen._ixnet.execute.call_count)
 689
 690     @mock.patch.object(ixnet_api.IxNextgen, '_get_traffic_state')
 691     def test_start_traffic_wait_for_traffic_start(
 692             self, mock_ixnextgen_get_traffic_state):
 693         self.ixnet_gen._ixnet.getList.return_value = [0]
 694         mock_ixnextgen_get_traffic_state.side_effect = [
 695             'stopped', 'stopped', 'stopped', 'started']
 696
 697         result = self.ixnet_gen.start_traffic()
 698         self.assertIsNone(result)
 699         self.ixnet.getList.assert_called_once()
 700         self.assertEqual(3, self.ixnet_gen._ixnet.execute.call_count)
 701
 702     def test_start_protocols(self):
 703         self.ixnet_gen.start_protocols()
 704         self.ixnet.execute.assert_called_once_with('startAllProtocols')
 705
 706     def test_stop_protocols(self):
 707         self.ixnet_gen.stop_protocols()
 708         self.ixnet.execute.assert_called_once_with('stopAllProtocols')
 709
 710     def test_get_vports(self):
 711         self.ixnet_gen._ixnet.getRoot.return_value = 'root'
 712         self.ixnet_gen.get_vports()
 713         self.ixnet.getList.assert_called_once_with('root', 'vport')