1 ##############################################################################
2 # Copyright (c) 2015 Ericsson AB and others.
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 ##############################################################################
14 from oslo_serialization import jsonutils
16 from yardstick.common import utils
17 from yardstick.benchmark.scenarios.networking import iperf3
18 from yardstick.common import exceptions as y_exc
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'
31 'key_filename': 'mykey.key'
36 'key_filename': 'mykey.key',
37 'ipaddr': '172.16.0.138',
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)
44 def _stop_mocks(self):
45 self._mock_log_info.stop()
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, '', '')
52 self.assertIsNotNone(p.target)
53 self.assertIsNotNone(p.host)
54 mock_ssh.SSH.from_node().execute.assert_called_with("iperf3 -s -D")
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)
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()
68 mock_ssh.SSH.from_node().close.assert_called()
69 mock_ssh.SSH.from_node().execute.assert_called_with("pkill iperf3")
71 def test_iperf_successful_no_sla(self, mock_ssh):
73 args = {'options': options}
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()
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))
84 self.assertEqual(result, expected_result)
86 def test_iperf_successful_sla(self, mock_ssh):
90 'sla': {'bytes_per_second': 15000000}
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()
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))
102 self.assertEqual(result, expected_result)
104 def test_iperf_unsuccessful_sla(self, mock_ssh):
108 'sla': {'bytes_per_second': 25000000}
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()
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)
120 def test_iperf_successful_sla_jitter(self, mock_ssh):
121 options = {"protocol": "udp", "bandwidth": "20m"}
124 'sla': {'jitter': 10}
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()
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))
136 self.assertEqual(result, expected_result)
138 def test_iperf_unsuccessful_sla_jitter(self, mock_ssh):
139 options = {"protocol": "udp", "bandwidth": "20m"}
142 'sla': {'jitter': 0.0001}
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()
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)
154 def test_iperf_successful_tcp_protocal(self, mock_ssh):
155 options = {"protocol": "tcp", "nodelay": "yes"}
158 'sla': {'bytes_per_second': 15000000}
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()
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))
170 self.assertEqual(result, expected_result)
172 def test_iperf_unsuccessful_script_error(self, mock_ssh):
174 args = {'options': options}
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()
181 mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
182 self.assertRaises(RuntimeError, p.run, result)
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()