yardstick/tests/unit/benchmark/scenarios/networking/test_pktgen.py

   1 ##############################################################################
   2 # Copyright (c) 2015 Ericsson AB and others.
   3 #
   4 # All rights reserved. This program and the accompanying materials
   5 # are made available under the terms of the Apache License, Version 2.0
   6 # which accompanies this distribution, and is available at
   7 # http://www.apache.org/licenses/LICENSE-2.0
   8 ##############################################################################
   9
  10 import mock
  11 import unittest
  12
  13 from oslo_serialization import jsonutils
  14
  15 from yardstick.benchmark.scenarios.networking import pktgen
  16 from yardstick.common import exceptions as y_exc
  17
  18
  19 @mock.patch('yardstick.benchmark.scenarios.networking.pktgen.ssh')
  20 class PktgenTestCase(unittest.TestCase):
  21
  22     def setUp(self):
  23         self.ctx = {
  24             'host': {
  25                 'ip': '172.16.0.137',
  26                 'user': 'root',
  27                 'key_filename': 'mykey.key'
  28             },
  29             'target': {
  30                 'ip': '172.16.0.138',
  31                 'user': 'root',
  32                 'key_filename': 'mykey.key',
  33                 'ipaddr': '172.16.0.138'
  34             }
  35         }
  36
  37     def test_pktgen_successful_setup(self, mock_ssh):
  38
  39         args = {
  40             'options': {'packetsize': 60},
  41         }
  42         p = pktgen.Pktgen(args, self.ctx)
  43         p.setup()
  44
  45         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
  46         self.assertIsNotNone(p.server)
  47         self.assertIsNotNone(p.client)
  48         self.assertTrue(p.setup_done)
  49
  50     def test_pktgen_successful_iptables_setup(self, mock_ssh):
  51
  52         args = {
  53             'options': {'packetsize': 60, 'number_of_ports': 10},
  54         }
  55         p = pktgen.Pktgen(args, self.ctx)
  56         p.server = mock_ssh.SSH.from_node()
  57         p.number_of_ports = args['options']['number_of_ports']
  58
  59         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
  60
  61         p._iptables_setup()
  62
  63         mock_ssh.SSH.from_node().execute.assert_called_with(
  64             "sudo iptables -F; "
  65             "sudo iptables -A INPUT -p udp --dport 1000:%s -j DROP"
  66             % 1010, timeout=60)
  67
  68     def test_pktgen_unsuccessful_iptables_setup(self, mock_ssh):
  69
  70         args = {
  71             'options': {'packetsize': 60, 'number_of_ports': 10},
  72         }
  73
  74         p = pktgen.Pktgen(args, self.ctx)
  75         p.server = mock_ssh.SSH.from_node()
  76         p.number_of_ports = args['options']['number_of_ports']
  77
  78         mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
  79         self.assertRaises(RuntimeError, p._iptables_setup)
  80
  81     def test_pktgen_successful_iptables_get_result(self, mock_ssh):
  82
  83         args = {
  84             'options': {'packetsize': 60, 'number_of_ports': 10},
  85         }
  86
  87         p = pktgen.Pktgen(args, self.ctx)
  88         p.server = mock_ssh.SSH.from_node()
  89         p.number_of_ports = args['options']['number_of_ports']
  90
  91         mock_ssh.SSH.from_node().execute.return_value = (0, '150000', '')
  92         p._iptables_get_result()
  93
  94         mock_ssh.SSH.from_node().execute.assert_called_with(
  95             "sudo iptables -L INPUT -vnx |"
  96             "awk '/dpts:1000:%s/ {{printf \"%%s\", $1}}'"
  97             % 1010)
  98
  99     def test_pktgen_unsuccessful_iptables_get_result(self, mock_ssh):
 100
 101         args = {
 102             'options': {'packetsize': 60, 'number_of_ports': 10},
 103         }
 104
 105         p = pktgen.Pktgen(args, self.ctx)
 106
 107         p.server = mock_ssh.SSH.from_node()
 108         p.number_of_ports = args['options']['number_of_ports']
 109
 110         mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
 111         self.assertRaises(RuntimeError, p._iptables_get_result)
 112
 113     def test_pktgen_successful_no_sla(self, mock_ssh):
 114
 115         args = {
 116             'options': {'packetsize': 60, 'number_of_ports': 10},
 117         }
 118         result = {}
 119
 120         p = pktgen.Pktgen(args, self.ctx)
 121
 122         p.server = mock_ssh.SSH.from_node()
 123         p.client = mock_ssh.SSH.from_node()
 124
 125         p._iptables_get_result = mock.Mock(return_value=149300)
 126
 127         sample_output = '{"packets_per_second": 9753, "errors": 0, \
 128             "packets_sent": 149776, "packetsize": 60, "flows": 110, "ppm": 3179}'
 129         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 130
 131         p.run(result)
 132         expected_result = jsonutils.loads(sample_output)
 133         expected_result["packets_received"] = 149300
 134         expected_result["packetsize"] = 60
 135         self.assertEqual(result, expected_result)
 136
 137     def test_pktgen_successful_sla(self, mock_ssh):
 138
 139         args = {
 140             'options': {'packetsize': 60, 'number_of_ports': 10},
 141             'sla': {'max_ppm': 10000}
 142         }
 143         result = {}
 144
 145         p = pktgen.Pktgen(args, self.ctx)
 146
 147         p.server = mock_ssh.SSH.from_node()
 148         p.client = mock_ssh.SSH.from_node()
 149
 150         p._iptables_get_result = mock.Mock(return_value=149300)
 151
 152         sample_output = '{"packets_per_second": 9753, "errors": 0, \
 153             "packets_sent": 149776, "packetsize": 60, "flows": 110, "ppm": 3179}'
 154         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 155
 156         p.run(result)
 157         expected_result = jsonutils.loads(sample_output)
 158         expected_result["packets_received"] = 149300
 159         expected_result["packetsize"] = 60
 160         self.assertEqual(result, expected_result)
 161
 162     def test_pktgen_unsuccessful_sla(self, mock_ssh):
 163
 164         args = {
 165             'options': {'packetsize': 60, 'number_of_ports': 10},
 166             'sla': {'max_ppm': 1000}
 167         }
 168         result = {}
 169
 170         p = pktgen.Pktgen(args, self.ctx)
 171
 172         p.server = mock_ssh.SSH.from_node()
 173         p.client = mock_ssh.SSH.from_node()
 174
 175         p._iptables_get_result = mock.Mock(return_value=149300)
 176
 177         sample_output = '{"packets_per_second": 9753, "errors": 0, \
 178             "packets_sent": 149776, "packetsize": 60, "flows": 110}'
 179         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 180         self.assertRaises(y_exc.SLAValidationError, p.run, result)
 181
 182     def test_pktgen_unsuccessful_script_error(self, mock_ssh):
 183
 184         args = {
 185             'options': {'packetsize': 60, 'number_of_ports': 10},
 186             'sla': {'max_ppm': 1000}
 187         }
 188         result = {}
 189
 190         p = pktgen.Pktgen(args, self.ctx)
 191
 192         p.server = mock_ssh.SSH.from_node()
 193         p.client = mock_ssh.SSH.from_node()
 194
 195         mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
 196         self.assertRaises(RuntimeError, p.run, result)
 197
 198     def test_pktgen_get_vnic_driver_name(self, mock_ssh):
 199         args = {
 200             'options': {'packetsize': 60},
 201         }
 202         p = pktgen.Pktgen(args, self.ctx)
 203         p.server = mock_ssh.SSH.from_node()
 204
 205         mock_ssh.SSH.from_node().execute.return_value = (0, 'ixgbevf', '')
 206
 207         vnic_driver_name = p._get_vnic_driver_name()
 208         self.assertEqual(vnic_driver_name, 'ixgbevf')
 209
 210     def test_pktgen_unsuccessful_get_vnic_driver_name(self, mock_ssh):
 211         args = {
 212             'options': {'packetsize': 60},
 213         }
 214         p = pktgen.Pktgen(args, self.ctx)
 215         p.server = mock_ssh.SSH.from_node()
 216
 217         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 218
 219         self.assertRaises(RuntimeError, p._get_vnic_driver_name)
 220
 221     def test_pktgen_get_sriov_queue_number(self, mock_ssh):
 222         args = {
 223             'options': {'packetsize': 60},
 224         }
 225         p = pktgen.Pktgen(args, self.ctx)
 226         p.server = mock_ssh.SSH.from_node()
 227
 228         mock_ssh.SSH.from_node().execute.return_value = (0, '2', '')
 229
 230         p.queue_number = p._get_sriov_queue_number()
 231         self.assertEqual(p.queue_number, 2)
 232
 233     def test_pktgen_unsuccessful_get_sriov_queue_number(self, mock_ssh):
 234         args = {
 235             'options': {'packetsize': 60},
 236         }
 237         p = pktgen.Pktgen(args, self.ctx)
 238         p.server = mock_ssh.SSH.from_node()
 239
 240         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 241
 242         self.assertRaises(RuntimeError, p._get_sriov_queue_number)
 243
 244     def test_pktgen_get_available_queue_number(self, mock_ssh):
 245         args = {
 246             'options': {'packetsize': 60},
 247         }
 248         p = pktgen.Pktgen(args, self.ctx)
 249         p.server = mock_ssh.SSH.from_node()
 250
 251         mock_ssh.SSH.from_node().execute.return_value = (0, '4', '')
 252
 253         p._get_available_queue_number()
 254
 255         mock_ssh.SSH.from_node().execute.assert_called_with(
 256             "sudo ethtool -l eth0 | grep Combined | head -1 |"
 257             "awk '{printf $2}'")
 258
 259     def test_pktgen_unsuccessful_get_available_queue_number(self, mock_ssh):
 260         args = {
 261             'options': {'packetsize': 60},
 262         }
 263         p = pktgen.Pktgen(args, self.ctx)
 264         p.server = mock_ssh.SSH.from_node()
 265
 266         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 267
 268         self.assertRaises(RuntimeError, p._get_available_queue_number)
 269
 270     def test_pktgen_get_usable_queue_number(self, mock_ssh):
 271         args = {
 272             'options': {'packetsize': 60},
 273         }
 274         p = pktgen.Pktgen(args, self.ctx)
 275         p.server = mock_ssh.SSH.from_node()
 276
 277         mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
 278
 279         p._get_usable_queue_number()
 280
 281         mock_ssh.SSH.from_node().execute.assert_called_with(
 282             "sudo ethtool -l eth0 | grep Combined | tail -1 |"
 283             "awk '{printf $2}'")
 284
 285     def test_pktgen_unsuccessful_get_usable_queue_number(self, mock_ssh):
 286         args = {
 287             'options': {'packetsize': 60},
 288         }
 289         p = pktgen.Pktgen(args, self.ctx)
 290         p.server = mock_ssh.SSH.from_node()
 291
 292         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 293
 294         self.assertRaises(RuntimeError, p._get_usable_queue_number)
 295
 296     def test_pktgen_enable_ovs_multiqueue(self, mock_ssh):
 297         args = {
 298             'options': {'packetsize': 60},
 299         }
 300         p = pktgen.Pktgen(args, self.ctx)
 301         p.server = mock_ssh.SSH.from_node()
 302         p.client = mock_ssh.SSH.from_node()
 303
 304         mock_ssh.SSH.from_node().execute.return_value = (0, '4', '')
 305
 306         p._get_usable_queue_number = mock.Mock(return_value=1)
 307         p._get_available_queue_number = mock.Mock(return_value=4)
 308
 309         p.queue_number = p._enable_ovs_multiqueue()
 310         self.assertEqual(p.queue_number, 4)
 311
 312     def test_pktgen_enable_ovs_multiqueue_1q(self, mock_ssh):
 313         args = {
 314             'options': {'packetsize': 60},
 315         }
 316         p = pktgen.Pktgen(args, self.ctx)
 317         p.server = mock_ssh.SSH.from_node()
 318         p.client = mock_ssh.SSH.from_node()
 319
 320         mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
 321
 322         p._get_usable_queue_number = mock.Mock(return_value=1)
 323         p._get_available_queue_number = mock.Mock(return_value=1)
 324
 325         p.queue_number = p._enable_ovs_multiqueue()
 326         self.assertEqual(p.queue_number, 1)
 327
 328     def test_pktgen_unsuccessful_enable_ovs_multiqueue(self, mock_ssh):
 329         args = {
 330             'options': {'packetsize': 60},
 331         }
 332         p = pktgen.Pktgen(args, self.ctx)
 333         p.server = mock_ssh.SSH.from_node()
 334         p.client = mock_ssh.SSH.from_node()
 335
 336         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 337
 338         p._get_usable_queue_number = mock.Mock(return_value=1)
 339         p._get_available_queue_number = mock.Mock(return_value=4)
 340
 341         self.assertRaises(RuntimeError, p._enable_ovs_multiqueue)
 342
 343     def test_pktgen_setup_irqmapping_ovs(self, mock_ssh):
 344         args = {
 345             'options': {'packetsize': 60},
 346         }
 347         p = pktgen.Pktgen(args, self.ctx)
 348         p.server = mock_ssh.SSH.from_node()
 349         p.client = mock_ssh.SSH.from_node()
 350
 351         mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
 352
 353         p._setup_irqmapping_ovs(4)
 354
 355         mock_ssh.SSH.from_node().execute.assert_called_with(
 356             "echo 8 | sudo tee /proc/irq/10/smp_affinity")
 357
 358     def test_pktgen_setup_irqmapping_ovs_1q(self, mock_ssh):
 359         args = {
 360             'options': {'packetsize': 60},
 361         }
 362         p = pktgen.Pktgen(args, self.ctx)
 363         p.server = mock_ssh.SSH.from_node()
 364         p.client = mock_ssh.SSH.from_node()
 365
 366         mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
 367
 368         p._setup_irqmapping_ovs(1)
 369
 370         mock_ssh.SSH.from_node().execute.assert_called_with(
 371             "echo 1 | sudo tee /proc/irq/10/smp_affinity")
 372
 373     def test_pktgen_unsuccessful_setup_irqmapping_ovs(self, mock_ssh):
 374         args = {
 375             'options': {'packetsize': 60},
 376         }
 377         p = pktgen.Pktgen(args, self.ctx)
 378         p.server = mock_ssh.SSH.from_node()
 379         p.client = mock_ssh.SSH.from_node()
 380
 381         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 382
 383         self.assertRaises(RuntimeError, p._setup_irqmapping_ovs, 4)
 384
 385     def test_pktgen_unsuccessful_setup_irqmapping_ovs_1q(self, mock_ssh):
 386         args = {
 387             'options': {'packetsize': 60},
 388         }
 389         p = pktgen.Pktgen(args, self.ctx)
 390         p.server = mock_ssh.SSH.from_node()
 391         p.client = mock_ssh.SSH.from_node()
 392
 393         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 394
 395         self.assertRaises(RuntimeError, p._setup_irqmapping_ovs, 1)
 396
 397     def test_pktgen_setup_irqmapping_sriov(self, mock_ssh):
 398         args = {
 399             'options': {'packetsize': 60},
 400         }
 401         p = pktgen.Pktgen(args, self.ctx)
 402         p.server = mock_ssh.SSH.from_node()
 403         p.client = mock_ssh.SSH.from_node()
 404
 405         mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
 406
 407         p._setup_irqmapping_sriov(2)
 408
 409         mock_ssh.SSH.from_node().execute.assert_called_with(
 410             "echo 2 | sudo tee /proc/irq/10/smp_affinity")
 411
 412     def test_pktgen_setup_irqmapping_sriov_1q(self, mock_ssh):
 413         args = {
 414             'options': {'packetsize': 60},
 415         }
 416         p = pktgen.Pktgen(args, self.ctx)
 417         p.server = mock_ssh.SSH.from_node()
 418         p.client = mock_ssh.SSH.from_node()
 419
 420         mock_ssh.SSH.from_node().execute.return_value = (0, '10', '')
 421
 422         p._setup_irqmapping_sriov(1)
 423
 424         mock_ssh.SSH.from_node().execute.assert_called_with(
 425             "echo 1 | sudo tee /proc/irq/10/smp_affinity")
 426
 427     def test_pktgen_unsuccessful_setup_irqmapping_sriov(self, mock_ssh):
 428         args = {
 429             'options': {'packetsize': 60},
 430         }
 431         p = pktgen.Pktgen(args, self.ctx)
 432         p.server = mock_ssh.SSH.from_node()
 433         p.client = mock_ssh.SSH.from_node()
 434
 435         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 436
 437         self.assertRaises(RuntimeError, p._setup_irqmapping_sriov, 2)
 438
 439     def test_pktgen_unsuccessful_setup_irqmapping_sriov_1q(self, mock_ssh):
 440         args = {
 441             'options': {'packetsize': 60},
 442         }
 443         p = pktgen.Pktgen(args, self.ctx)
 444         p.server = mock_ssh.SSH.from_node()
 445         p.client = mock_ssh.SSH.from_node()
 446
 447         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 448
 449         self.assertRaises(RuntimeError, p._setup_irqmapping_sriov, 1)
 450
 451     def test_pktgen_is_irqbalance_disabled(self, mock_ssh):
 452         args = {
 453             'options': {'packetsize': 60},
 454         }
 455         p = pktgen.Pktgen(args, self.ctx)
 456         p.server = mock_ssh.SSH.from_node()
 457
 458         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 459
 460         p._is_irqbalance_disabled()
 461
 462         mock_ssh.SSH.from_node().execute.assert_called_with(
 463             "grep ENABLED /etc/default/irqbalance")
 464
 465     def test_pktgen_unsuccessful_is_irqbalance_disabled(self, mock_ssh):
 466         args = {
 467             'options': {'packetsize': 60},
 468         }
 469         p = pktgen.Pktgen(args, self.ctx)
 470         p.server = mock_ssh.SSH.from_node()
 471
 472         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 473
 474         self.assertRaises(RuntimeError, p._is_irqbalance_disabled)
 475
 476     def test_pktgen_disable_irqbalance(self, mock_ssh):
 477         args = {
 478             'options': {'packetsize': 60},
 479         }
 480         p = pktgen.Pktgen(args, self.ctx)
 481         p.server = mock_ssh.SSH.from_node()
 482         p.client = mock_ssh.SSH.from_node()
 483
 484         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 485
 486         p._disable_irqbalance()
 487
 488         mock_ssh.SSH.from_node().execute.assert_called_with(
 489             "sudo service irqbalance disable")
 490
 491     def test_pktgen_unsuccessful_disable_irqbalance(self, mock_ssh):
 492         args = {
 493             'options': {'packetsize': 60},
 494         }
 495         p = pktgen.Pktgen(args, self.ctx)
 496         p.server = mock_ssh.SSH.from_node()
 497         p.client = mock_ssh.SSH.from_node()
 498
 499         mock_ssh.SSH.from_node().execute.return_value = (1, '', '')
 500
 501         self.assertRaises(RuntimeError, p._disable_irqbalance)
 502
 503     def test_pktgen_multiqueue_setup_ovs(self, mock_ssh):
 504         args = {
 505             'options': {'packetsize': 60, 'multiqueue': True},
 506         }
 507         p = pktgen.Pktgen(args, self.ctx)
 508         p.server = mock_ssh.SSH.from_node()
 509         p.client = mock_ssh.SSH.from_node()
 510
 511         mock_ssh.SSH.from_node().execute.return_value = (0, '4', '')
 512
 513         p._is_irqbalance_disabled = mock.Mock(return_value=False)
 514         p._get_vnic_driver_name = mock.Mock(return_value="virtio_net")
 515         p._get_usable_queue_number = mock.Mock(return_value=1)
 516         p._get_available_queue_number = mock.Mock(return_value=4)
 517
 518         p.multiqueue_setup()
 519
 520         self.assertEqual(p.queue_number, 4)
 521
 522     def test_pktgen_multiqueue_setup_ovs_1q(self, mock_ssh):
 523         args = {
 524             'options': {'packetsize': 60, 'multiqueue': True},
 525         }
 526         p = pktgen.Pktgen(args, self.ctx)
 527         p.server = mock_ssh.SSH.from_node()
 528         p.client = mock_ssh.SSH.from_node()
 529
 530         mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
 531
 532         p._is_irqbalance_disabled = mock.Mock(return_value=False)
 533         p._get_vnic_driver_name = mock.Mock(return_value="virtio_net")
 534         p._get_usable_queue_number = mock.Mock(return_value=1)
 535         p._get_available_queue_number = mock.Mock(return_value=1)
 536
 537         p.multiqueue_setup()
 538
 539         self.assertEqual(p.queue_number, 1)
 540
 541     def test_pktgen_multiqueue_setup_sriov(self, mock_ssh):
 542         args = {
 543             'options': {'packetsize': 60, 'multiqueue': True},
 544         }
 545         p = pktgen.Pktgen(args, self.ctx)
 546         p.server = mock_ssh.SSH.from_node()
 547         p.client = mock_ssh.SSH.from_node()
 548
 549         mock_ssh.SSH.from_node().execute.return_value = (0, '2', '')
 550
 551         p._is_irqbalance_disabled = mock.Mock(return_value=False)
 552         p._get_vnic_driver_name = mock.Mock(return_value="ixgbevf")
 553
 554         p.multiqueue_setup()
 555
 556         self.assertEqual(p.queue_number, 2)
 557
 558     def test_pktgen_multiqueue_setup_sriov_1q(self, mock_ssh):
 559         args = {
 560             'options': {'packetsize': 60, 'multiqueue': True},
 561         }
 562         p = pktgen.Pktgen(args, self.ctx)
 563         p.server = mock_ssh.SSH.from_node()
 564         p.client = mock_ssh.SSH.from_node()
 565
 566         mock_ssh.SSH.from_node().execute.return_value = (0, '1', '')
 567
 568         p._is_irqbalance_disabled = mock.Mock(return_value=False)
 569         p._get_vnic_driver_name = mock.Mock(return_value="ixgbevf")
 570
 571         p.multiqueue_setup()
 572
 573         self.assertEqual(p.queue_number, 1)
 574
 575     def test_pktgen_run_with_setup_done(self, mock_ssh):
 576         args = {
 577             'options': {
 578                 'packetsize': 60,
 579                 'number_of_ports': 10,
 580                 'duration': 20,
 581                 'multiqueue': True},
 582             'sla': {
 583                 'max_ppm': 1}}
 584         result = {}
 585         p = pktgen.Pktgen(args, self.ctx)
 586         p.server = mock_ssh.SSH.from_node()
 587         p.client = mock_ssh.SSH.from_node()
 588
 589         p.setup_done = True
 590         p.multiqueue_setup_done = True
 591
 592         mock_iptables_result = mock.Mock()
 593         mock_iptables_result.return_value = 149300
 594         p._iptables_get_result = mock_iptables_result
 595
 596         sample_output = '{"packets_per_second": 9753, "errors": 0, \
 597             "packets_sent": 149300, "flows": 110, "ppm": 0}'
 598         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 599
 600         p.run(result)
 601         expected_result = jsonutils.loads(sample_output)
 602         expected_result["packets_received"] = 149300
 603         expected_result["packetsize"] = 60
 604         self.assertEqual(result, expected_result)
 605
 606     def test_pktgen_run_with_ovs_multiqueque(self, mock_ssh):
 607         args = {
 608             'options': {
 609                 'packetsize': 60,
 610                 'number_of_ports': 10,
 611                 'duration': 20,
 612                 'multiqueue': True},
 613             'sla': {
 614                 'max_ppm': 1}}
 615         result = {}
 616
 617         p = pktgen.Pktgen(args, self.ctx)
 618
 619         p.server = mock_ssh.SSH.from_node()
 620         p.client = mock_ssh.SSH.from_node()
 621
 622         p._get_vnic_driver_name = mock.Mock(return_value="virtio_net")
 623         p._get_usable_queue_number = mock.Mock(return_value=1)
 624         p._get_available_queue_number = mock.Mock(return_value=4)
 625         p._enable_ovs_multiqueue = mock.Mock(return_value=4)
 626         p._setup_irqmapping_ovs = mock.Mock()
 627         p._iptables_get_result = mock.Mock(return_value=149300)
 628
 629         sample_output = '{"packets_per_second": 9753, "errors": 0, \
 630             "packets_sent": 149300, "flows": 110, "ppm": 0}'
 631         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 632
 633         p.run(result)
 634         expected_result = jsonutils.loads(sample_output)
 635         expected_result["packets_received"] = 149300
 636         expected_result["packetsize"] = 60
 637         self.assertEqual(result, expected_result)
 638
 639     def test_pktgen_run_with_sriov_multiqueque(self, mock_ssh):
 640         args = {
 641             'options': {
 642                 'packetsize': 60,
 643                 'number_of_ports': 10,
 644                 'duration': 20,
 645                 'multiqueue': True},
 646             'sla': {
 647                 'max_ppm': 1}}
 648         result = {}
 649
 650         p = pktgen.Pktgen(args, self.ctx)
 651
 652         p.server = mock_ssh.SSH.from_node()
 653         p.client = mock_ssh.SSH.from_node()
 654
 655         p._get_vnic_driver_name = mock.Mock(return_value="ixgbevf")
 656         p._get_sriov_queue_number = mock.Mock(return_value=2)
 657         p._setup_irqmapping_sriov = mock.Mock()
 658         p._iptables_get_result = mock.Mock(return_value=149300)
 659
 660         sample_output = '{"packets_per_second": 9753, "errors": 0, \
 661             "packets_sent": 149300, "flows": 110, "ppm": 0}'
 662         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 663
 664         p.run(result)
 665         expected_result = jsonutils.loads(sample_output)
 666         expected_result["packets_received"] = 149300
 667         expected_result["packetsize"] = 60
 668         self.assertEqual(result, expected_result)