Replace nova delete keypair with shade client.
[yardstick.git] / yardstick / tests / unit / benchmark / scenarios / compute / test_ramspeed.py
1 ##############################################################################
2 # Copyright (c) 2016 Huawei Technologies Co.,Ltd 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 # Unittest for yardstick.benchmark.scenarios.compute.ramspeed.Ramspeed
11
12 from __future__ import absolute_import
13
14 import unittest
15
16 import mock
17 from oslo_serialization import jsonutils
18
19 from yardstick.common import utils
20 from yardstick.benchmark.scenarios.compute import ramspeed
21
22
23 @mock.patch('yardstick.benchmark.scenarios.compute.ramspeed.ssh')
24 class RamspeedTestCase(unittest.TestCase):
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         }
34
35         self.result = {}
36
37     def test_ramspeed_successful_setup(self, mock_ssh):
38
39         r = ramspeed.Ramspeed({}, self.ctx)
40         mock_ssh.SSH.from_node().execute.return_value = (0, '', '')
41
42         r.setup()
43         self.assertIsNotNone(r.client)
44         self.assertTrue(r.setup_done, True)
45
46     def test_ramspeed_successful__run_no_sla(self, mock_ssh):
47
48         options = {
49             "test_id": 1,
50             "load": 16,
51             "block_size": 32
52         }
53         args = {"options": options}
54         r = ramspeed.Ramspeed(args, self.ctx)
55
56         sample_output = '{"Result": [{"Test_type": "INTEGER & WRITING",\
57  "Block_size(kb)": 1, "Bandwidth(MBps)": 19909.18}, {"Test_type":\
58  "INTEGER & WRITING", "Block_size(kb)": 2, "Bandwidth(MBps)": 19873.89},\
59  {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 4, "Bandwidth(MBps)":\
60  19907.56}, {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 8,\
61  "Bandwidth(MBps)": 19906.94}, {"Test_type": "INTEGER & WRITING",\
62  "Block_size(kb)": 16, "Bandwidth(MBps)": 19881.74}, {"Test_type":\
63  "INTEGER & WRITING", "Block_size(kb)": 32, "Bandwidth(MBps)": 19395.65},\
64  {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 64, "Bandwidth(MBps)":\
65  17623.14}, {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 128,\
66  "Bandwidth(MBps)": 17677.36}, {"Test_type": "INTEGER & WRITING",\
67  "Block_size(kb)": 256, "Bandwidth(MBps)": 16113.49}, {"Test_type":\
68  "INTEGER & WRITING", "Block_size(kb)": 512, "Bandwidth(MBps)": 14659.19},\
69  {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 1024, "Bandwidth(MBps)":\
70  14680.75}, {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 2048,\
71  "Bandwidth(MBps)": 14756.45}, {"Test_type": "INTEGER & WRITING",\
72  "Block_size(kb)": 4096, "Bandwidth(MBps)": 14604.44}, {"Test_type":\
73  "INTEGER & WRITING", "Block_size(kb)": 8192, "Bandwidth(MBps)": 14159.86},\
74  {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 16384,\
75  "Bandwidth(MBps)": 14128.94}, {"Test_type": "INTEGER & WRITING",\
76  "Block_size(kb)": 32768, "Bandwidth(MBps)": 8340.85}]}'
77         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
78         r.run(self.result)
79         expected_result = utils.flatten_dict_key(jsonutils.loads(sample_output))
80         self.assertEqual(self.result, expected_result)
81
82     def test_ramspeed_successful_run_sla(self, mock_ssh):
83
84         options = {
85             "test_id": 1,
86             "load": 16,
87             "block_size": 32
88         }
89         args = {"options": options, "sla": {"min_bandwidth": 6000}}
90         r = ramspeed.Ramspeed(args, self.ctx)
91
92         sample_output = '{"Result": [{"Test_type": "INTEGER & WRITING",\
93  "Block_size(kb)": 1, "Bandwidth(MBps)": 19909.18}, {"Test_type":\
94  "INTEGER & WRITING", "Block_size(kb)": 2, "Bandwidth(MBps)": 19873.89},\
95  {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 4, "Bandwidth(MBps)":\
96  19907.56}, {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 8,\
97  "Bandwidth(MBps)": 19906.94}, {"Test_type": "INTEGER & WRITING",\
98  "Block_size(kb)": 16, "Bandwidth(MBps)": 19881.74}, {"Test_type":\
99  "INTEGER & WRITING", "Block_size(kb)": 32, "Bandwidth(MBps)": 19395.65},\
100  {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 64, "Bandwidth(MBps)":\
101  17623.14}, {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 128,\
102  "Bandwidth(MBps)": 17677.36}, {"Test_type": "INTEGER & WRITING",\
103  "Block_size(kb)": 256, "Bandwidth(MBps)": 16113.49}, {"Test_type":\
104  "INTEGER & WRITING", "Block_size(kb)": 512, "Bandwidth(MBps)": 14659.19},\
105  {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 1024, "Bandwidth(MBps)":\
106  14680.75}, {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 2048,\
107  "Bandwidth(MBps)": 14756.45}, {"Test_type": "INTEGER & WRITING",\
108  "Block_size(kb)": 4096, "Bandwidth(MBps)": 14604.44}, {"Test_type":\
109  "INTEGER & WRITING", "Block_size(kb)": 8192, "Bandwidth(MBps)": 14159.86},\
110  {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 16384,\
111  "Bandwidth(MBps)": 14128.94}, {"Test_type": "INTEGER & WRITING",\
112  "Block_size(kb)": 32768, "Bandwidth(MBps)": 8340.85}]}'
113         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
114         r.run(self.result)
115         expected_result = utils.flatten_dict_key(jsonutils.loads(sample_output))
116         self.assertEqual(self.result, expected_result)
117
118     def test_ramspeed_unsuccessful_run_sla(self, mock_ssh):
119         options = {
120             "test_id": 1,
121             "load": 8,
122             "block_size": 64
123         }
124         args = {"options": options, "sla": {"min_bandwidth": 100000}}
125         r = ramspeed.Ramspeed(args, self.ctx)
126
127         sample_output = '{"Result": [{"Test_type": "INTEGER & WRITING",\
128  "Block_size(kb)": 1, "Bandwidth(MBps)": 5000.18}, {"Test_type":\
129  "INTEGER & WRITING", "Block_size(kb)": 2, "Bandwidth(MBps)": 5000.89},\
130  {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 4,\
131  "Bandwidth(MBps)": 5000.56}, {"Test_type": "INTEGER & WRITING",\
132  "Block_size(kb)": 8, "Bandwidth(MBps)": 19906.94}, {"Test_type":\
133  "INTEGER & WRITING", "Block_size(kb)": 16, "Bandwidth(MBps)": 19881.74},\
134  {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 32,\
135  "Bandwidth(MBps)": 19395.65}, {"Test_type": "INTEGER & WRITING",\
136  "Block_size(kb)": 64, "Bandwidth(MBps)": 17623.14}, {"Test_type":\
137  "INTEGER & WRITING", "Block_size(kb)": 128, "Bandwidth(MBps)": 17677.36},\
138  {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 256, "Bandwidth(MBps)":\
139  16113.49}, {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 512,\
140  "Bandwidth(MBps)": 14659.19}, {"Test_type": "INTEGER & WRITING",\
141  "Block_size(kb)": 1024, "Bandwidth(MBps)": 14680.75}, {"Test_type":\
142  "INTEGER & WRITING", "Block_size(kb)": 2048, "Bandwidth(MBps)": 14756.45},\
143  {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 4096, "Bandwidth(MBps)":\
144  14604.44}, {"Test_type": "INTEGER & WRITING", "Block_size(kb)": 8192,\
145  "Bandwidth(MBps)": 14159.86}, {"Test_type": "INTEGER & WRITING",\
146  "Block_size(kb)": 16384, "Bandwidth(MBps)": 14128.94}, {"Test_type":\
147  "INTEGER & WRITING", "Block_size(kb)": 32768, "Bandwidth(MBps)": 8340.85}]}'
148         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
149         self.assertRaises(AssertionError, r.run, self.result)
150
151     def test_ramspeed_unsuccessful_script_error(self, mock_ssh):
152         options = {
153             "test_id": 1,
154             "load": 16,
155             "block_size": 32
156         }
157         args = {"options": options}
158         r = ramspeed.Ramspeed(args, self.ctx)
159
160         mock_ssh.SSH.from_node().execute.return_value = (1, '', 'FOOBAR')
161         self.assertRaises(RuntimeError, r.run, self.result)
162
163     def test_ramspeed_mem_successful_run_no_sla(self, mock_ssh):
164         options = {
165             "test_id": 3,
166             "load": 16,
167             "block_size": 32,
168             "iteration": 1
169         }
170         args = {"options": options}
171         r = ramspeed.Ramspeed(args, self.ctx)
172
173         sample_output = '{"Result": [{"Test_type": "INTEGER Copy:",\
174  "Bandwidth(MBps)": 8353.97}, {"Test_type": "INTEGER Scale:",\
175  "Bandwidth(MBps)": 9078.59}, {"Test_type": "INTEGER Add:",\
176  "Bandwidth(MBps)": 10057.48}, {"Test_type": "INTEGER Triad:",\
177  "Bandwidth(MBps)": 10116.27}, {"Test_type": "INTEGER AVERAGE:",\
178  "Bandwidth(MBps)": 9401.58}]}'
179         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
180         r.run(self.result)
181         expected_result = utils.flatten_dict_key(jsonutils.loads(sample_output))
182         self.assertEqual(self.result, expected_result)
183
184     def test_ramspeed_mem_successful_run_sla(self, mock_ssh):
185         options = {
186             "test_id": 3,
187             "load": 16,
188             "block_size": 32,
189             "iteration": 1
190         }
191         args = {"options": options, "sla": {"min_bandwidth": 6000}}
192         r = ramspeed.Ramspeed(args, self.ctx)
193
194         sample_output = '{"Result": [{"Test_type": "INTEGER Copy:",\
195  "Bandwidth(MBps)": 8353.97}, {"Test_type": "INTEGER Scale:",\
196  "Bandwidth(MBps)": 9078.59}, {"Test_type": "INTEGER Add:",\
197  "Bandwidth(MBps)": 10057.48}, {"Test_type": "INTEGER Triad:",\
198  "Bandwidth(MBps)": 10116.27}, {"Test_type": "INTEGER AVERAGE:",\
199  "Bandwidth(MBps)": 9401.58}]}'
200         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
201         r.run(self.result)
202         expected_result = utils.flatten_dict_key(jsonutils.loads(sample_output))
203         self.assertEqual(self.result, expected_result)
204
205     def test_ramspeed_mem_unsuccessful_run_sla(self, mock_ssh):
206         options = {
207             "test_id": 3,
208             "load": 16,
209             "block_size": 32,
210             "iteration": 1
211         }
212         args = {"options": options, "sla": {"min_bandwidth": 86000}}
213         r = ramspeed.Ramspeed(args, self.ctx)
214
215         sample_output = '{"Result": [{"Test_type": "INTEGER Copy:",\
216  "Bandwidth(MBps)": 4000.97}, {"Test_type": "INTEGER Scale:",\
217  "Bandwidth(MBps)": 4400.59}, {"Test_type": "INTEGER Add:",\
218  "Bandwidth(MBps)": 4300.48}, {"Test_type": "INTEGER Triad:",\
219  "Bandwidth(MBps)": 1300.27}, {"Test_type": "INTEGER AVERAGE:",\
220  "Bandwidth(MBps)": 2401.58}]}'
221         mock_ssh.SSH.from_node().execute.return_value = (0, sample_output, '')
222         self.assertRaises(AssertionError, r.run, self.result)
223
224     def test_ramspeed_unsuccessful_unknown_type_run(self, mock_ssh):
225         options = {
226             "test_id": 30,
227             "load": 16,
228             "block_size": 32
229         }
230         args = {'options': options}
231         r = ramspeed.Ramspeed(args, self.ctx)
232
233         mock_ssh.SSH.from_node().execute.return_value = (1, '', 'No such type_id: 30 for \
234                                                Ramspeed scenario')
235         self.assertRaises(RuntimeError, r.run, self.result)