functest/tests/unit/utils/test_functest_utils.py

   1 #!/usr/bin/env python
   2
   3 # Copyright (c) 2016 Orange and others.
   4 #
   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
   9
  10 import logging
  11 import os
  12 import time
  13 import unittest
  14 import urllib2
  15
  16 from git.exc import NoSuchPathError
  17 import mock
  18 import requests
  19
  20 from functest.tests.unit import test_utils
  21 from functest.utils import functest_utils
  22
  23
  24 class FunctestUtilsTesting(unittest.TestCase):
  25
  26     logging.disable(logging.CRITICAL)
  27
  28     def setUp(self):
  29         self.url = 'http://www.opnfv.org/'
  30         self.timeout = 5
  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'
  44         self.success_rate = 2.0
  45         self.criteria = 'test_criteria==2.0'
  46         self.start_date = 1482624000
  47         self.stop_date = 1482624000
  48         self.start_time = time.time()
  49         self.stop_time = time.time()
  50         self.readline = -1
  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'
  54         self.cmd = 'test_cmd'
  55         self.output_file = 'test_output_file'
  56         self.testname = 'testname'
  57         self.testcase_dict = {'case_name': 'testname',
  58                               'criteria': self.criteria}
  59         self.parameter = 'general.openstack.image_name'
  60         self.config_yaml = 'test_config_yaml-'
  61         self.db_url_env = 'http://foo/testdb'
  62         self.file_yaml = {'general': {'openstack': {'image_name':
  63                                                     'test_image_name'}}}
  64
  65     @mock.patch('urllib2.urlopen',
  66                 side_effect=urllib2.URLError('no host given'))
  67     def test_check_internet_connectivity_failed(self, mock_method):
  68         self.assertFalse(functest_utils.check_internet_connectivity())
  69         mock_method.assert_called_once_with(self.url, timeout=self.timeout)
  70
  71     @mock.patch('urllib2.urlopen')
  72     def test_check_internet_connectivity_default(self, mock_method):
  73         self.assertTrue(functest_utils.check_internet_connectivity())
  74         mock_method.assert_called_once_with(self.url, timeout=self.timeout)
  75
  76     @mock.patch('urllib2.urlopen')
  77     def test_check_internet_connectivity_debian(self, mock_method):
  78         self.url = "https://www.debian.org/"
  79         self.assertTrue(functest_utils.check_internet_connectivity(self.url))
  80         mock_method.assert_called_once_with(self.url, timeout=self.timeout)
  81
  82     @mock.patch('urllib2.urlopen',
  83                 side_effect=urllib2.URLError('no host given'))
  84     def test_download_url_failed(self, mock_url):
  85         self.assertFalse(functest_utils.download_url(self.url, self.dest_path))
  86
  87     @mock.patch('urllib2.urlopen')
  88     def test_download_url_default(self, mock_url):
  89         with mock.patch("__builtin__.open", mock.mock_open()) as m, \
  90                 mock.patch('functest.utils.functest_utils.shutil.copyfileobj')\
  91                 as mock_sh:
  92             name = self.url.rsplit('/')[-1]
  93             dest = self.dest_path + "/" + name
  94             self.assertTrue(functest_utils.download_url(self.url,
  95                                                         self.dest_path))
  96             m.assert_called_once_with(dest, 'wb')
  97             self.assertTrue(mock_sh.called)
  98
  99     def test_get_git_branch(self):
 100         with mock.patch('functest.utils.functest_utils.Repo') as mock_repo:
 101             mock_obj2 = mock.Mock()
 102             attrs = {'name': 'test_branch'}
 103             mock_obj2.configure_mock(**attrs)
 104
 105             mock_obj = mock.Mock()
 106             attrs = {'active_branch': mock_obj2}
 107             mock_obj.configure_mock(**attrs)
 108
 109             mock_repo.return_value = mock_obj
 110             self.assertEqual(functest_utils.get_git_branch(self.repo_path),
 111                              'test_branch')
 112
 113     @mock.patch('functest.utils.functest_utils.Repo',
 114                 side_effect=NoSuchPathError)
 115     def test_get_git_branch_failed(self, mock_repo):
 116         self.assertRaises(NoSuchPathError,
 117                           lambda: functest_utils.get_git_branch(self.repo_path
 118                                                                 ))
 119
 120     @mock.patch('functest.utils.functest_utils.logger.error')
 121     def test_get_installer_type_failed(self, mock_logger_error):
 122         with mock.patch.dict(os.environ,
 123                              {},
 124                              clear=True):
 125             self.assertEqual(functest_utils.get_installer_type(),
 126                              "Unknown_installer")
 127             mock_logger_error.assert_called_once_with("Impossible to retrieve"
 128                                                       " the installer type")
 129
 130     def test_get_installer_type_default(self):
 131         with mock.patch.dict(os.environ,
 132                              {'INSTALLER_TYPE': 'test_installer'},
 133                              clear=True):
 134             self.assertEqual(functest_utils.get_installer_type(),
 135                              self.installer)
 136
 137     @mock.patch('functest.utils.functest_utils.logger.info')
 138     def test_get_scenario_failed(self, mock_logger_info):
 139         with mock.patch.dict(os.environ,
 140                              {},
 141                              clear=True):
 142             self.assertEqual(functest_utils.get_scenario(),
 143                              "os-nosdn-nofeature-noha")
 144             mock_logger_info.assert_called_once_with("Impossible to retrieve "
 145                                                      "the scenario.Use "
 146                                                      "default "
 147                                                      "os-nosdn-nofeature-noha")
 148
 149     def test_get_scenario_default(self):
 150         with mock.patch.dict(os.environ,
 151                              {'DEPLOY_SCENARIO': 'test_scenario'},
 152                              clear=True):
 153             self.assertEqual(functest_utils.get_scenario(),
 154                              self.scenario)
 155
 156     @mock.patch('functest.utils.functest_utils.get_build_tag')
 157     def test_get_version_daily_job(self, mock_get_build_tag):
 158         mock_get_build_tag.return_value = self.build_tag
 159         self.assertEqual(functest_utils.get_version(), self.version)
 160
 161     @mock.patch('functest.utils.functest_utils.get_build_tag')
 162     def test_get_version_weekly_job(self, mock_get_build_tag):
 163         mock_get_build_tag.return_value = self.build_tag_week
 164         self.assertEqual(functest_utils.get_version(), self.version)
 165
 166     @mock.patch('functest.utils.functest_utils.get_build_tag')
 167     def test_get_version_with_dummy_build_tag(self, mock_get_build_tag):
 168         mock_get_build_tag.return_value = 'whatever'
 169         self.assertEqual(functest_utils.get_version(), 'unknown')
 170
 171     @mock.patch('functest.utils.functest_utils.get_build_tag')
 172     def test_get_version_unknown(self, mock_get_build_tag):
 173         mock_get_build_tag.return_value = "unknown_build_tag"
 174         self.assertEqual(functest_utils.get_version(), "unknown")
 175
 176     @mock.patch('functest.utils.functest_utils.logger.info')
 177     def test_get_pod_name_failed(self, mock_logger_info):
 178         with mock.patch.dict(os.environ,
 179                              {},
 180                              clear=True):
 181             self.assertEqual(functest_utils.get_pod_name(),
 182                              "unknown-pod")
 183             mock_logger_info.assert_called_once_with("Unable to retrieve "
 184                                                      "the POD name from "
 185                                                      "environment. Using "
 186                                                      "pod name 'unknown-pod'")
 187
 188     def test_get_pod_name_default(self):
 189         with mock.patch.dict(os.environ,
 190                              {'NODE_NAME': 'test_node_name'},
 191                              clear=True):
 192             self.assertEqual(functest_utils.get_pod_name(),
 193                              self.node_name)
 194
 195     @mock.patch('functest.utils.functest_utils.logger.info')
 196     def test_get_build_tag_failed(self, mock_logger_info):
 197         with mock.patch.dict(os.environ,
 198                              {},
 199                              clear=True):
 200             self.assertEqual(functest_utils.get_build_tag(),
 201                              "none")
 202             mock_logger_info.assert_called_once_with("Impossible to retrieve"
 203                                                      " the build tag")
 204
 205     def test_get_build_tag_default(self):
 206         with mock.patch.dict(os.environ,
 207                              {'BUILD_TAG': self.build_tag},
 208                              clear=True):
 209             self.assertEqual(functest_utils.get_build_tag(),
 210                              self.build_tag)
 211
 212     def test_get_db_url_env_var(self):
 213         with mock.patch.dict(os.environ,
 214                              {'TEST_DB_URL': self.db_url_env,
 215                               'CONFIG_FUNCTEST_YAML':
 216                               "./functest/ci/config_functest.yaml"},
 217                              clear=True):
 218             self.assertEqual(functest_utils.get_db_url(),
 219                              self.db_url_env)
 220
 221     @mock.patch('functest.utils.functest_utils.get_functest_config')
 222     def test_get_db_url_default(self, mock_get_functest_config):
 223         mock_get_functest_config.return_value = self.db_url
 224         self.assertEqual(functest_utils.get_db_url(), self.db_url)
 225         mock_get_functest_config.assert_called_once_with('results.test_db_url')
 226
 227     @mock.patch('functest.utils.functest_utils.logger.info')
 228     def test_logger_test_results(self, mock_logger_info):
 229         with mock.patch('functest.utils.functest_utils.get_pod_name',
 230                         return_value=self.node_name), \
 231                 mock.patch('functest.utils.functest_utils.get_scenario',
 232                            return_value=self.scenario), \
 233                 mock.patch('functest.utils.functest_utils.get_version',
 234                            return_value=self.version), \
 235                 mock.patch('functest.utils.functest_utils.get_build_tag',
 236                            return_value=self.build_tag), \
 237                 mock.patch('functest.utils.functest_utils.get_db_url',
 238                            return_value=self.db_url):
 239             functest_utils.logger_test_results(self.project, self.case_name,
 240                                                self.status, self.details)
 241             mock_logger_info.assert_called_once_with(
 242                 "\n"
 243                 "****************************************\n"
 244                 "\t %(p)s/%(n)s results \n\n"
 245                 "****************************************\n"
 246                 "DB:\t%(db)s\n"
 247                 "pod:\t%(pod)s\n"
 248                 "version:\t%(v)s\n"
 249                 "scenario:\t%(s)s\n"
 250                 "status:\t%(c)s\n"
 251                 "build tag:\t%(b)s\n"
 252                 "details:\t%(d)s\n"
 253                 % {'p': self.project,
 254                     'n': self.case_name,
 255                     'db': self.db_url,
 256                     'pod': self.node_name,
 257                     'v': self.version,
 258                     's': self.scenario,
 259                     'c': self.status,
 260                     'b': self.build_tag,
 261                     'd': self.details})
 262
 263     def _get_env_dict(self, var):
 264         dic = {'INSTALLER_TYPE': self.installer,
 265                'DEPLOY_SCENARIO': self.scenario,
 266                'NODE_NAME': self.node_name,
 267                'BUILD_TAG': self.build_tag}
 268         dic.pop(var, None)
 269         return dic
 270
 271     def _test_push_results_to_db_missing_env(self, env_var):
 272         dic = self._get_env_dict(env_var)
 273         with mock.patch('functest.utils.functest_utils.get_db_url',
 274                         return_value=self.db_url), \
 275                 mock.patch.dict(os.environ,
 276                                 dic,
 277                                 clear=True), \
 278                 mock.patch('functest.utils.functest_utils.logger.error') \
 279                 as mock_logger_error:
 280             functest_utils.push_results_to_db(self.project, self.case_name,
 281                                               self.start_date, self.stop_date,
 282                                               self.criteria, self.details)
 283             mock_logger_error.assert_called_once_with("Please set env var: " +
 284                                                       str("\'" + env_var +
 285                                                           "\'"))
 286
 287     def test_push_results_to_db_missing_installer(self):
 288         self._test_push_results_to_db_missing_env('INSTALLER_TYPE')
 289
 290     def test_push_results_to_db_missing_scenario(self):
 291         self._test_push_results_to_db_missing_env('DEPLOY_SCENARIO')
 292
 293     def test_push_results_to_db_missing_nodename(self):
 294         self._test_push_results_to_db_missing_env('NODE_NAME')
 295
 296     def test_push_results_to_db_missing_buildtag(self):
 297         self._test_push_results_to_db_missing_env('BUILD_TAG')
 298
 299     def test_push_results_to_db_request_post_failed(self):
 300         dic = self._get_env_dict(None)
 301         with mock.patch('functest.utils.functest_utils.get_db_url',
 302                         return_value=self.db_url), \
 303                 mock.patch.dict(os.environ,
 304                                 dic,
 305                                 clear=True), \
 306                 mock.patch('functest.utils.functest_utils.logger.error') \
 307                 as mock_logger_error, \
 308                 mock.patch('functest.utils.functest_utils.requests.post',
 309                            side_effect=requests.RequestException):
 310             self.assertFalse(functest_utils.
 311                              push_results_to_db(self.project, self.case_name,
 312                                                 self.start_date,
 313                                                 self.stop_date,
 314                                                 self.criteria, self.details))
 315             mock_logger_error.assert_called_once_with(test_utils.
 316                                                       RegexMatch("Pushing "
 317                                                                  "Result to"
 318                                                                  " DB"
 319                                                                  "(\S+\s*) "
 320                                                                  "failed:"))
 321
 322     def test_push_results_to_db_request_post_exception(self):
 323         dic = self._get_env_dict(None)
 324         with mock.patch('functest.utils.functest_utils.get_db_url',
 325                         return_value=self.db_url), \
 326                 mock.patch.dict(os.environ,
 327                                 dic,
 328                                 clear=True), \
 329                 mock.patch('functest.utils.functest_utils.logger.error') \
 330                 as mock_logger_error, \
 331                 mock.patch('functest.utils.functest_utils.requests.post',
 332                            side_effect=Exception):
 333             self.assertFalse(functest_utils.
 334                              push_results_to_db(self.project, self.case_name,
 335                                                 self.start_date,
 336                                                 self.stop_date,
 337                                                 self.criteria, self.details))
 338             self.assertTrue(mock_logger_error.called)
 339
 340     def test_push_results_to_db_default(self):
 341         dic = self._get_env_dict(None)
 342         with mock.patch('functest.utils.functest_utils.get_db_url',
 343                         return_value=self.db_url), \
 344                 mock.patch.dict(os.environ,
 345                                 dic,
 346                                 clear=True), \
 347                 mock.patch('functest.utils.functest_utils.requests.post'):
 348             self.assertTrue(functest_utils.
 349                             push_results_to_db(self.project, self.case_name,
 350                                                self.start_date,
 351                                                self.stop_date,
 352                                                self.criteria, self.details))
 353     readline = 0
 354     test_ip = ['10.1.23.4', '10.1.14.15', '10.1.16.15']
 355
 356     @staticmethod
 357     def readline_side():
 358         if FunctestUtilsTesting.readline == \
 359                 len(FunctestUtilsTesting.test_ip) - 1:
 360             return False
 361         FunctestUtilsTesting.readline += 1
 362         return FunctestUtilsTesting.test_ip[FunctestUtilsTesting.readline]
 363
 364     # TODO: get_resolvconf_ns
 365     @mock.patch('functest.utils.functest_utils.dns.resolver.Resolver')
 366     def test_get_resolvconf_ns_default(self, mock_dns_resolve):
 367         attrs = {'query.return_value': ["test"]}
 368         mock_dns_resolve.configure_mock(**attrs)
 369
 370         m = mock.Mock()
 371         attrs = {'readline.side_effect': self.readline_side}
 372         m.configure_mock(**attrs)
 373
 374         with mock.patch("__builtin__.open") as mo:
 375             mo.return_value = m
 376             self.assertEqual(functest_utils.get_resolvconf_ns(),
 377                              self.test_ip[1:])
 378
 379     def _get_environ(self, var):
 380         if var == 'INSTALLER_TYPE':
 381             return self.installer
 382         elif var == 'DEPLOY_SCENARIO':
 383             return self.scenario
 384         return var
 385
 386     def test_get_ci_envvars_default(self):
 387         with mock.patch('os.environ.get',
 388                         side_effect=self._get_environ):
 389             dic = {"installer": self.installer,
 390                    "scenario": self.scenario}
 391             self.assertDictEqual(functest_utils.get_ci_envvars(), dic)
 392
 393     def cmd_readline(self):
 394         return 'test_value\n'
 395
 396     @mock.patch('functest.utils.functest_utils.logger.error')
 397     @mock.patch('functest.utils.functest_utils.logger.info')
 398     def test_execute_command_args_present_with_error(self, mock_logger_info,
 399                                                      mock_logger_error):
 400         with mock.patch('functest.utils.functest_utils.subprocess.Popen') \
 401                 as mock_subproc_open, \
 402                 mock.patch('__builtin__.open', mock.mock_open()) as mopen:
 403
 404             FunctestUtilsTesting.readline = 0
 405
 406             mock_obj = mock.Mock()
 407             attrs = {'readline.side_effect': self.cmd_readline()}
 408             mock_obj.configure_mock(**attrs)
 409
 410             mock_obj2 = mock.Mock()
 411             attrs = {'stdout': mock_obj, 'wait.return_value': 1}
 412             mock_obj2.configure_mock(**attrs)
 413
 414             mock_subproc_open.return_value = mock_obj2
 415
 416             resp = functest_utils.execute_command(self.cmd, info=True,
 417                                                   error_msg=self.error_msg,
 418                                                   verbose=True,
 419                                                   output_file=self.output_file)
 420             self.assertEqual(resp, 1)
 421             msg_exec = ("Executing command: '%s'" % self.cmd)
 422             mock_logger_info.assert_called_once_with(msg_exec)
 423             mopen.assert_called_once_with(self.output_file, "w")
 424             mock_logger_error.assert_called_once_with(self.error_msg)
 425
 426     @mock.patch('functest.utils.functest_utils.logger.info')
 427     def test_execute_command_args_present_with_success(self, mock_logger_info,
 428                                                        ):
 429         with mock.patch('functest.utils.functest_utils.subprocess.Popen') \
 430                 as mock_subproc_open, \
 431                 mock.patch('__builtin__.open', mock.mock_open()) as mopen:
 432
 433             FunctestUtilsTesting.readline = 0
 434
 435             mock_obj = mock.Mock()
 436             attrs = {'readline.side_effect': self.cmd_readline()}
 437             mock_obj.configure_mock(**attrs)
 438
 439             mock_obj2 = mock.Mock()
 440             attrs = {'stdout': mock_obj, 'wait.return_value': 0}
 441             mock_obj2.configure_mock(**attrs)
 442
 443             mock_subproc_open.return_value = mock_obj2
 444
 445             resp = functest_utils.execute_command(self.cmd, info=True,
 446                                                   error_msg=self.error_msg,
 447                                                   verbose=True,
 448                                                   output_file=self.output_file)
 449             self.assertEqual(resp, 0)
 450             msg_exec = ("Executing command: '%s'" % self.cmd)
 451             mock_logger_info.assert_called_once_with(msg_exec)
 452             mopen.assert_called_once_with(self.output_file, "w")
 453
 454     @mock.patch('functest.utils.functest_utils.logger.info')
 455     def test_execute_command_args_missing_with_success(self, mock_logger_info,
 456                                                        ):
 457         with mock.patch('functest.utils.functest_utils.subprocess.Popen') \
 458                 as mock_subproc_open:
 459
 460             FunctestUtilsTesting.readline = 2
 461
 462             mock_obj = mock.Mock()
 463             attrs = {'readline.side_effect': self.cmd_readline()}
 464             mock_obj.configure_mock(**attrs)
 465
 466             mock_obj2 = mock.Mock()
 467             attrs = {'stdout': mock_obj, 'wait.return_value': 0}
 468             mock_obj2.configure_mock(**attrs)
 469
 470             mock_subproc_open.return_value = mock_obj2
 471
 472             resp = functest_utils.execute_command(self.cmd, info=False,
 473                                                   error_msg="",
 474                                                   verbose=False,
 475                                                   output_file=None)
 476             self.assertEqual(resp, 0)
 477
 478     @mock.patch('functest.utils.functest_utils.logger.error')
 479     def test_execute_command_args_missing_with_error(self, mock_logger_error,
 480                                                      ):
 481         with mock.patch('functest.utils.functest_utils.subprocess.Popen') \
 482                 as mock_subproc_open:
 483
 484             FunctestUtilsTesting.readline = 2
 485             mock_obj = mock.Mock()
 486             attrs = {'readline.side_effect': self.cmd_readline()}
 487             mock_obj.configure_mock(**attrs)
 488
 489             mock_obj2 = mock.Mock()
 490             attrs = {'stdout': mock_obj, 'wait.return_value': 1}
 491             mock_obj2.configure_mock(**attrs)
 492
 493             mock_subproc_open.return_value = mock_obj2
 494
 495             resp = functest_utils.execute_command(self.cmd, info=False,
 496                                                   error_msg="",
 497                                                   verbose=False,
 498                                                   output_file=None)
 499             self.assertEqual(resp, 1)
 500
 501     def _get_functest_config(self, var):
 502         return var
 503
 504     @mock.patch('functest.utils.functest_utils.logger.error')
 505     def test_get_dict_by_test(self, mock_logger_error):
 506         with mock.patch('__builtin__.open', mock.mock_open()), \
 507                 mock.patch('functest.utils.functest_utils.yaml.safe_load') \
 508                 as mock_yaml, \
 509                 mock.patch('functest.utils.functest_utils.get_testcases_'
 510                            'file_dir'):
 511             mock_obj = mock.Mock()
 512             attrs = {'get.return_value': [{'testcases': [self.testcase_dict]}]}
 513             mock_obj.configure_mock(**attrs)
 514
 515             mock_yaml.return_value = mock_obj
 516
 517             self.assertDictEqual(functest_utils.
 518                                  get_dict_by_test(self.testname),
 519                                  self.testcase_dict)
 520
 521     @mock.patch('functest.utils.functest_utils.get_dict_by_test')
 522     def test_get_criteria_by_test_default(self, mock_get_dict_by_test):
 523         mock_get_dict_by_test.return_value = self.testcase_dict
 524         self.assertEqual(functest_utils.get_criteria_by_test(self.testname),
 525                          self.criteria)
 526
 527     @mock.patch('functest.utils.functest_utils.get_dict_by_test')
 528     def test_get_criteria_by_test_failed(self, mock_get_dict_by_test):
 529         mock_get_dict_by_test.return_value = None
 530         self.assertIsNone(functest_utils.get_criteria_by_test(self.testname))
 531
 532     def test_get_parameter_from_yaml_failed(self):
 533         self.file_yaml['general'] = None
 534         with mock.patch('__builtin__.open', mock.mock_open()), \
 535                 mock.patch('functest.utils.functest_utils.yaml.safe_load') \
 536                 as mock_yaml, \
 537                 self.assertRaises(ValueError) as excep:
 538             mock_yaml.return_value = self.file_yaml
 539             functest_utils.get_parameter_from_yaml(self.parameter,
 540                                                    self.test_file)
 541             self.assertTrue(("The parameter %s is not"
 542                              " defined in config_functest.yaml" %
 543                              self.parameter) in excep.exception)
 544
 545     def test_get_parameter_from_yaml_default(self):
 546         with mock.patch('__builtin__.open', mock.mock_open()), \
 547                 mock.patch('functest.utils.functest_utils.yaml.safe_load') \
 548                 as mock_yaml:
 549             mock_yaml.return_value = self.file_yaml
 550             self.assertEqual(functest_utils.
 551                              get_parameter_from_yaml(self.parameter,
 552                                                      self.test_file),
 553                              'test_image_name')
 554
 555     @mock.patch('functest.utils.functest_utils.get_parameter_from_yaml')
 556     def test_get_functest_config_default(self, mock_get_parameter_from_yaml):
 557         with mock.patch.dict(os.environ,
 558                              {'CONFIG_FUNCTEST_YAML': self.config_yaml}):
 559             functest_utils.get_functest_config(self.parameter)
 560             mock_get_parameter_from_yaml. \
 561                 assert_called_once_with(self.parameter,
 562                                         self.config_yaml)
 563
 564     def test_check_success_rate_default(self):
 565         with mock.patch('functest.utils.functest_utils.get_criteria_by_test') \
 566                 as mock_criteria:
 567             mock_criteria.return_value = self.criteria
 568             resp = functest_utils.check_success_rate(self.case_name,
 569                                                      self.success_rate)
 570             self.assertEqual(resp, 'PASS')
 571
 572     def test_check_success_rate_failed(self):
 573         with mock.patch('functest.utils.functest_utils.get_criteria_by_test') \
 574                 as mock_criteria:
 575             mock_criteria.return_value = self.criteria
 576             resp = functest_utils.check_success_rate(self.case_name,
 577                                                      3.0)
 578             self.assertEqual(resp, 'FAIL')
 579
 580     # TODO: merge_dicts
 581
 582     def test_get_testcases_file_dir(self):
 583         resp = functest_utils.get_testcases_file_dir()
 584         self.assertEqual(resp,
 585                          "/home/opnfv/repos/functest/"
 586                          "functest/ci/testcases.yaml")
 587
 588     def test_get_functest_yaml(self):
 589         with mock.patch('__builtin__.open', mock.mock_open()), \
 590                 mock.patch('functest.utils.functest_utils.yaml.safe_load') \
 591                 as mock_yaml:
 592             mock_yaml.return_value = self.file_yaml
 593             resp = functest_utils.get_functest_yaml()
 594             self.assertEqual(resp, self.file_yaml)
 595
 596     @mock.patch('functest.utils.functest_utils.logger.info')
 597     def test_print_separator(self, mock_logger_info):
 598         functest_utils.print_separator()
 599         mock_logger_info.assert_called_once_with("======================="
 600                                                  "=======================")
 601
 602
 603 if __name__ == "__main__":
 604     unittest.main(verbosity=2)