3 # Copyright (c) 2016 Orange and others.
5 # All rights reserved. This program and the accompanying materials
6 # are made available under the terms of the Apache License, Version 2.0
7 # which accompanies this distribution, and is available at
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # pylint: disable=missing-docstring
19 from functest.utils import functest_utils
22 class FunctestUtilsTesting(unittest.TestCase):
23 # pylint: disable=too-many-instance-attributes,too-many-public-methods
26 test_ip = ['10.1.23.4', '10.1.14.15', '10.1.16.15']
29 self.url = 'http://www.opnfv.org/'
31 self.dest_path = 'test_path'
32 self.repo_path = 'test_repo_path'
33 self.installer = 'test_installer'
34 self.scenario = 'test_scenario'
35 self.build_tag = 'jenkins-functest-fuel-opnfv-jump-2-daily-master-190'
36 self.build_tag_week = 'jenkins-functest-fuel-baremetal-weekly-master-8'
37 self.version = 'master'
38 self.node_name = 'test_node_name'
39 self.project = 'test_project'
40 self.case_name = 'test_case_name'
41 self.status = 'test_status'
42 self.details = 'test_details'
43 self.db_url = 'test_db_url'
46 self.start_date = 1482624000
47 self.stop_date = 1482624000
48 self.start_time = time.time()
49 self.stop_time = time.time()
51 self.test_ip = ['10.1.23.4', '10.1.14.15', '10.1.16.15']
52 self.test_file = 'test_file'
53 self.error_msg = 'test_error_msg'
55 self.output_file = 'test_output_file'
56 self.testname = 'testname'
57 self.parameter = 'general.openstack.image_name'
58 self.config_yaml = pkg_resources.resource_filename(
59 'functest', 'ci/config_functest.yaml')
60 self.db_url_env = 'http://foo/testdb'
61 self.testcases_yaml = "test_testcases_yaml"
62 self.file_yaml = {'general': {'openstack': {'image_name':
65 def _get_env_dict(self, var):
66 dic = {'INSTALLER_TYPE': self.installer,
67 'DEPLOY_SCENARIO': self.scenario,
68 'NODE_NAME': self.node_name,
69 'BUILD_TAG': self.build_tag}
75 if FunctestUtilsTesting.readline == \
76 len(FunctestUtilsTesting.test_ip) - 1:
78 FunctestUtilsTesting.readline += 1
79 return FunctestUtilsTesting.test_ip[FunctestUtilsTesting.readline]
81 def _get_environ(self, var, *args): # pylint: disable=unused-argument
82 if var == 'INSTALLER_TYPE':
84 elif var == 'DEPLOY_SCENARIO':
92 @mock.patch('functest.utils.functest_utils.LOGGER.error')
93 @mock.patch('functest.utils.functest_utils.LOGGER.info')
94 def test_exec_cmd_args_present_ko(self, mock_logger_info,
96 with mock.patch('functest.utils.functest_utils.subprocess.Popen') \
97 as mock_subproc_open, \
98 mock.patch('six.moves.builtins.open',
99 mock.mock_open()) as mopen:
101 FunctestUtilsTesting.readline = 0
103 mock_obj = mock.Mock()
104 attrs = {'readline.side_effect': self.cmd_readline()}
105 mock_obj.configure_mock(**attrs)
107 mock_obj2 = mock.Mock()
108 attrs = {'stdout': mock_obj, 'wait.return_value': 1}
109 mock_obj2.configure_mock(**attrs)
111 mock_subproc_open.return_value = mock_obj2
113 resp = functest_utils.execute_command(self.cmd, info=True,
114 error_msg=self.error_msg,
116 output_file=self.output_file)
117 self.assertEqual(resp, 1)
118 msg_exec = ("Executing command: '%s'" % self.cmd)
119 mock_logger_info.assert_called_once_with(msg_exec)
120 mopen.assert_called_once_with(self.output_file, "w")
121 mock_logger_error.assert_called_once_with(self.error_msg)
123 @mock.patch('functest.utils.functest_utils.LOGGER.info')
124 def test_exec_cmd_args_present_ok(self, mock_logger_info):
125 with mock.patch('functest.utils.functest_utils.subprocess.Popen') \
126 as mock_subproc_open, \
127 mock.patch('six.moves.builtins.open',
128 mock.mock_open()) as mopen:
130 FunctestUtilsTesting.readline = 0
132 mock_obj = mock.Mock()
133 attrs = {'readline.side_effect': self.cmd_readline()}
134 mock_obj.configure_mock(**attrs)
136 mock_obj2 = mock.Mock()
137 attrs = {'stdout': mock_obj, 'wait.return_value': 0}
138 mock_obj2.configure_mock(**attrs)
140 mock_subproc_open.return_value = mock_obj2
142 resp = functest_utils.execute_command(self.cmd, info=True,
143 error_msg=self.error_msg,
145 output_file=self.output_file)
146 self.assertEqual(resp, 0)
147 msg_exec = ("Executing command: '%s'" % self.cmd)
148 mock_logger_info.assert_called_once_with(msg_exec)
149 mopen.assert_called_once_with(self.output_file, "w")
151 @mock.patch('sys.stdout')
152 def test_exec_cmd_args_missing_ok(self, stdout=None):
153 # pylint: disable=unused-argument
154 with mock.patch('functest.utils.functest_utils.subprocess.Popen') \
155 as mock_subproc_open:
157 FunctestUtilsTesting.readline = 2
159 mock_obj = mock.Mock()
160 attrs = {'readline.side_effect': self.cmd_readline()}
161 mock_obj.configure_mock(**attrs)
163 mock_obj2 = mock.Mock()
164 attrs = {'stdout': mock_obj, 'wait.return_value': 0}
165 mock_obj2.configure_mock(**attrs)
167 mock_subproc_open.return_value = mock_obj2
169 resp = functest_utils.execute_command(self.cmd, info=False,
173 self.assertEqual(resp, 0)
175 @mock.patch('sys.stdout')
176 def test_exec_cmd_args_missing_ko(self, stdout=None):
177 # pylint: disable=unused-argument
178 with mock.patch('functest.utils.functest_utils.subprocess.Popen') \
179 as mock_subproc_open:
181 FunctestUtilsTesting.readline = 2
182 mock_obj = mock.Mock()
183 attrs = {'readline.side_effect': self.cmd_readline()}
184 mock_obj.configure_mock(**attrs)
186 mock_obj2 = mock.Mock()
187 attrs = {'stdout': mock_obj, 'wait.return_value': 1}
188 mock_obj2.configure_mock(**attrs)
190 mock_subproc_open.return_value = mock_obj2
192 resp = functest_utils.execute_command(self.cmd, info=False,
196 self.assertEqual(resp, 1)
198 def test_get_param_from_yaml_failed(self):
199 self.file_yaml['general'] = None
200 with mock.patch('six.moves.builtins.open', mock.mock_open()), \
201 mock.patch('functest.utils.functest_utils.yaml.safe_load') \
203 self.assertRaises(ValueError) as excep:
204 mock_yaml.return_value = self.file_yaml
205 functest_utils.get_parameter_from_yaml(self.parameter,
207 self.assertTrue(("The parameter %s is not"
208 " defined in config_functest.yaml" %
209 self.parameter) in excep.exception)
211 def test_get_param_from_yaml_def(self):
212 with mock.patch('six.moves.builtins.open', mock.mock_open()), \
213 mock.patch('functest.utils.functest_utils.yaml.safe_load') \
215 mock_yaml.return_value = self.file_yaml
216 self.assertEqual(functest_utils.
217 get_parameter_from_yaml(self.parameter,
221 def test_nova_version_exc1(self):
222 # pylint: disable=protected-access
224 cloud._compute_client.request.return_value = None
225 self.assertEqual(functest_utils.get_nova_version(cloud), None)
226 cloud._compute_client.request.assert_called_once_with('/', 'GET')
228 def test_nova_version_exc2(self):
229 # pylint: disable=protected-access
231 cloud._compute_client.request.return_value = {"version": None}
232 self.assertEqual(functest_utils.get_nova_version(cloud), None)
233 cloud._compute_client.request.assert_called_once_with('/', 'GET')
235 def test_nova_version_exc3(self):
236 # pylint: disable=protected-access
238 cloud._compute_client.request.return_value = {
239 "version": {"version": None}}
240 self.assertEqual(functest_utils.get_nova_version(cloud), None)
241 cloud._compute_client.request.assert_called_once_with('/', 'GET')
243 def test_nova_version_exc4(self):
244 # pylint: disable=protected-access
246 cloud._compute_client.request.return_value = {
247 "version": {"version": "a.b"}}
248 self.assertEqual(functest_utils.get_nova_version(cloud), None)
249 cloud._compute_client.request.assert_called_once_with('/', 'GET')
251 def test_nova_version(self):
252 # pylint: disable=protected-access
254 cloud._compute_client.request.return_value = {
255 "version": {"version": "2.1"}}
256 self.assertEqual(functest_utils.get_nova_version(cloud), (2, 1))
257 cloud._compute_client.request.assert_called_once_with('/', 'GET')
259 @mock.patch('functest.utils.functest_utils.get_nova_version',
260 return_value=(2, 61))
261 def test_openstack_version1(self, *args):
263 self.assertEqual(functest_utils.get_openstack_version(
265 args[0].assert_called_once_with(cloud)
267 @mock.patch('functest.utils.functest_utils.get_nova_version',
268 return_value=(2, 60))
269 def test_openstack_version2(self, *args):
271 self.assertEqual(functest_utils.get_openstack_version(cloud), "Queens")
272 args[0].assert_called_once_with(cloud)
274 @mock.patch('functest.utils.functest_utils.get_nova_version',
275 return_value=(2, 43))
276 def test_openstack_version3(self, *args):
278 self.assertEqual(functest_utils.get_openstack_version(cloud), "Pike")
279 args[0].assert_called_once_with(cloud)
281 @mock.patch('functest.utils.functest_utils.get_nova_version',
282 return_value=(2, 39))
283 def test_openstack_version4(self, *args):
285 self.assertEqual(functest_utils.get_openstack_version(cloud), "Ocata")
286 args[0].assert_called_once_with(cloud)
288 @mock.patch('functest.utils.functest_utils.get_nova_version',
289 return_value=(2, 26))
290 def test_openstack_version5(self, *args):
292 self.assertEqual(functest_utils.get_openstack_version(cloud), "Newton")
293 args[0].assert_called_once_with(cloud)
295 @mock.patch('functest.utils.functest_utils.get_nova_version',
296 return_value=(2, 13))
297 def test_openstack_version6(self, *args):
299 self.assertEqual(functest_utils.get_openstack_version(cloud), "Mitaka")
300 args[0].assert_called_once_with(cloud)
302 @mock.patch('functest.utils.functest_utils.get_nova_version',
304 def test_openstack_version7(self, *args):
307 functest_utils.get_openstack_version(cloud), "Liberty")
308 args[0].assert_called_once_with(cloud)
310 @mock.patch('functest.utils.functest_utils.get_nova_version',
312 def test_openstack_version8(self, *args):
314 self.assertEqual(functest_utils.get_openstack_version(cloud), "Kilo")
315 args[0].assert_called_once_with(cloud)
317 @mock.patch('functest.utils.functest_utils.get_nova_version',
319 def test_openstack_version9(self, *args):
322 functest_utils.get_openstack_version(cloud), "Unknown")
323 args[0].assert_called_once_with(cloud)
325 @mock.patch('functest.utils.functest_utils.get_nova_version',
327 def test_openstack_version10(self, *args):
330 functest_utils.get_openstack_version(cloud), "Master")
331 args[0].assert_called_once_with(cloud)
333 @mock.patch('functest.utils.functest_utils.get_nova_version',
335 def test_openstack_version_exc(self, *args):
338 functest_utils.get_openstack_version(cloud), "Unknown")
339 args[0].assert_called_once_with(cloud)
341 def test_convert_dict_to_ini(self):
343 functest_utils.convert_dict_to_ini({}), "")
345 functest_utils.convert_dict_to_ini({"a": "b"}), "a:b")
346 value = functest_utils.convert_dict_to_ini({"a": "b", "c": "d"})
347 self.assertTrue(value == "a:b,c:d" or value == "c:d,a:b")
348 with self.assertRaises(AssertionError):
349 functest_utils.convert_list_to_ini("")
351 def test_convert_list_to_ini(self):
353 functest_utils.convert_list_to_ini([]), "")
355 functest_utils.convert_list_to_ini(["a"]), "a")
357 functest_utils.convert_list_to_ini(["a", "b"]), "a,b")
358 with self.assertRaises(AssertionError):
359 functest_utils.convert_list_to_ini("")
361 def test_convert_ini_to_dict(self):
363 functest_utils.convert_ini_to_dict(""), {})
365 functest_utils.convert_ini_to_dict("a:b"), {"a": "b"})
367 functest_utils.convert_ini_to_dict(
368 "a:b,c:d"), {"a": "b", "c": "d"})
370 functest_utils.convert_ini_to_dict(
371 "a:b:c,d:e:f"), {"a:b": "c", "d:e": "f"})
372 with self.assertRaises(AssertionError):
373 functest_utils.convert_list_to_ini({})
375 def test_convert_ini_to_list(self):
377 functest_utils.convert_ini_to_list(""), [])
379 functest_utils.convert_ini_to_list("a"), ["a"])
381 functest_utils.convert_ini_to_list("a,b"), ["a", "b"])
382 with self.assertRaises(AssertionError):
383 functest_utils.convert_ini_to_list([])
386 if __name__ == "__main__":
387 logging.disable(logging.CRITICAL)
388 unittest.main(verbosity=2)