yardstick/tests/unit/benchmark/scenarios/networking/test_iperf3.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 os
  11 import unittest
  12
  13 import mock
  14 from oslo_serialization import jsonutils
  15
  16 from yardstick.common import utils
  17 from yardstick.benchmark.scenarios.networking import iperf3
  18 from yardstick.common import exceptions as y_exc
  19
  20
  21 @mock.patch.object(iperf3, 'ssh')
  22 class IperfTestCase(unittest.TestCase):
  23     output_name_tcp = 'iperf3_sample_output.json'
  24     output_name_udp = 'iperf3_sample_output_udp.json'
  25
  26     def setUp(self):
  27         self.ctx = {
  28             'host': {
  29                 'ip': '172.16.0.137',
  30                 'user': 'root',
  31                 'key_filename': 'mykey.key'
  32             },
  33             'target': {
  34                 'ip': '172.16.0.138',
  35                 'user': 'root',
  36                 'key_filename': 'mykey.key',
  37                 'ipaddr': '172.16.0.138',
  38             }
  39         }
  40         self._mock_log_info = mock.patch.object(iperf3.LOG, 'info')
  41         self.mock_log_info = self._mock_log_info.start()
  42         self.addCleanup(self._stop_mocks)
  43
  44     def _stop_mocks(self):
  45         self._mock_log_info.stop()
  46
  47     def test_iperf_successful_setup(self, mock_ssh):
  48         p = iperf3.Iperf({}, self.ctx)
  49         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
  50
  51         p.setup()
  52         self.assertIsNotNone(p.target)
  53         self.assertIsNotNone(p.host)
  54         mock_ssh.SSH.from_node().execute.assert_called_with("iperf3 -s -D")
  55
  56     def test_iperf_unsuccessful_setup(self, mock_ssh):
  57         p = iperf3.Iperf({}, self.ctx)
  58         mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
  59         self.assertRaises(RuntimeError, p.setup)
  60
  61     def test_iperf_successful_teardown(self, mock_ssh):
  62         p = iperf3.Iperf({}, self.ctx)
  63         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
  64         p.host = mock_ssh.SSH.from_node()
  65         p.target = mock_ssh.SSH.from_node()
  66
  67         p.teardown()
  68         mock_ssh.SSH.from_node().close.assert_called()
  69         mock_ssh.SSH.from_node().execute.assert_called_with("pkill iperf3")
  70
  71     def test_iperf_successful_no_sla(self, mock_ssh):
  72         options = {}
  73         args = {'options': options}
  74         result = {}
  75
  76         p = iperf3.Iperf(args, self.ctx)
  77         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
  78         p.host = mock_ssh.SSH.from_node()
  79
  80         sample_output = self._read_sample_output(self.output_name_tcp)
  81         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
  82         expected_result = utils.flatten_dict_key(jsonutils.loads(sample_output))
  83         p.run(result)
  84         self.assertEqual(result, expected_result)
  85
  86     def test_iperf_successful_sla(self, mock_ssh):
  87         options = {}
  88         args = {
  89             'options': options,
  90             'sla': {'bytes_per_second': 15000000}
  91         }
  92         result = {}
  93
  94         p = iperf3.Iperf(args, self.ctx)
  95         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
  96         p.host = mock_ssh.SSH.from_node()
  97
  98         sample_output = self._read_sample_output(self.output_name_tcp)
  99         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 100         expected_result = utils.flatten_dict_key(jsonutils.loads(sample_output))
 101         p.run(result)
 102         self.assertEqual(result, expected_result)
 103
 104     def test_iperf_unsuccessful_sla(self, mock_ssh):
 105         options = {}
 106         args = {
 107             'options': options,
 108             'sla': {'bytes_per_second': 25000000}
 109         }
 110         result = {}
 111
 112         p = iperf3.Iperf(args, self.ctx)
 113         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 114         p.host = mock_ssh.SSH.from_node()
 115
 116         sample_output = self._read_sample_output(self.output_name_tcp)
 117         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 118         self.assertRaises(y_exc.SLAValidationError, p.run, result)
 119
 120     def test_iperf_successful_sla_jitter(self, mock_ssh):
 121         options = {"protocol": "udp", "bandwidth": "20m"}
 122         args = {
 123             'options': options,
 124             'sla': {'jitter': 10}
 125         }
 126         result = {}
 127
 128         p = iperf3.Iperf(args, self.ctx)
 129         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 130         p.host = mock_ssh.SSH.from_node()
 131
 132         sample_output = self._read_sample_output(self.output_name_udp)
 133         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 134         expected_result = utils.flatten_dict_key(jsonutils.loads(sample_output))
 135         p.run(result)
 136         self.assertEqual(result, expected_result)
 137
 138     def test_iperf_unsuccessful_sla_jitter(self, mock_ssh):
 139         options = {"protocol": "udp", "bandwidth": "20m"}
 140         args = {
 141             'options': options,
 142             'sla': {'jitter': 0.0001}
 143         }
 144         result = {}
 145
 146         p = iperf3.Iperf(args, self.ctx)
 147         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 148         p.host = mock_ssh.SSH.from_node()
 149
 150         sample_output = self._read_sample_output(self.output_name_udp)
 151         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 152         self.assertRaises(y_exc.SLAValidationError, p.run, result)
 153
 154     def test_iperf_successful_tcp_protocal(self, mock_ssh):
 155         options = {"protocol": "tcp", "nodelay": "yes"}
 156         args = {
 157             'options': options,
 158             'sla': {'bytes_per_second': 15000000}
 159         }
 160         result = {}
 161
 162         p = iperf3.Iperf(args, self.ctx)
 163         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 164         p.host = mock_ssh.SSH.from_node()
 165
 166         sample_output = self._read_sample_output(self.output_name_tcp)
 167         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
 168         expected_result = utils.flatten_dict_key(jsonutils.loads(sample_output))
 169         p.run(result)
 170         self.assertEqual(result, expected_result)
 171
 172     def test_iperf_unsuccessful_script_error(self, mock_ssh):
 173         options = {}
 174         args = {'options': options}
 175         result = {}
 176
 177         p = iperf3.Iperf(args, self.ctx)
 178         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
 179         p.host = mock_ssh.SSH.from_node()
 180
 181         mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
 182         self.assertRaises(RuntimeError, p.run, result)
 183
 184     @staticmethod
 185     def _read_sample_output(filename):
 186         curr_path = os.path.dirname(os.path.abspath(__file__))
 187         output = os.path.join(curr_path, filename)
 188         with open(output) as f:
 189             sample_output = f.read()
 190         return sample_output