functest/tests/unit/ci/test_run_tests.py

   1 #!/usr/bin/env python
   2
   3 # All rights reserved. This program and the accompanying materials
   4 # are made available under the terms of the Apache License, Version 2.0
   5 # which accompanies this distribution, and is available at
   6 # http://www.apache.org/licenses/LICENSE-2.0
   7
   8 import logging
   9 import unittest
  10
  11 import mock
  12
  13 from functest.ci import run_tests
  14 from functest.utils.constants import CONST
  15 from functest.core.testcase import TestCase
  16
  17
  18 class FakeModule(TestCase):
  19
  20     def run(self):
  21         return TestCase.EX_OK
  22
  23     def push_to_db(self):
  24         return TestCase.EX_OK
  25
  26     def is_successful(self):
  27         return TestCase.EX_OK
  28
  29
  30 class RunTestsTesting(unittest.TestCase):
  31
  32     def setUp(self):
  33         self.runner = run_tests.Runner()
  34         self.sep = 'test_sep'
  35         self.creds = {'OS_AUTH_URL': 'http://test_ip:test_port/v2.0',
  36                       'OS_USERNAME': 'test_os_username',
  37                       'OS_TENANT_NAME': 'test_tenant',
  38                       'OS_PASSWORD': 'test_password'}
  39         self.test = {'test_name': 'test_name'}
  40         self.tier = mock.Mock()
  41         test1 = mock.Mock()
  42         test1.get_name.return_value = 'test1'
  43         test2 = mock.Mock()
  44         test2.get_name.return_value = 'test2'
  45         attrs = {'get_name.return_value': 'test_tier',
  46                  'get_tests.return_value': [test1, test2],
  47                  'get_ci_loop.return_value': 'test_ci_loop',
  48                  'get_test_names.return_value': ['test1', 'test2']}
  49         self.tier.configure_mock(**attrs)
  50
  51         self.tiers = mock.Mock()
  52         attrs = {'get_tiers.return_value': [self.tier]}
  53         self.tiers.configure_mock(**attrs)
  54
  55         self.run_tests_parser = run_tests.RunTestsParser()
  56
  57     @mock.patch('functest.ci.run_tests.logger.error')
  58     def test_source_rc_file_missing_file(self, mock_logger_error):
  59         with mock.patch('functest.ci.run_tests.os.path.isfile',
  60                         return_value=False), \
  61                 self.assertRaises(Exception):
  62             self.runner.source_rc_file()
  63
  64     @mock.patch('functest.ci.run_tests.logger.debug')
  65     @mock.patch('functest.ci.run_tests.os.path.isfile',
  66                 return_value=True)
  67     def test_source_rc_file_default(self, *args):
  68         with mock.patch('functest.ci.run_tests.os_utils.source_credentials',
  69                         return_value=self.creds):
  70             self.runner.source_rc_file()
  71
  72     def test_get_run_dict_if_defined_default(self):
  73         mock_obj = mock.Mock()
  74         with mock.patch('functest.ci.run_tests.'
  75                         'ft_utils.get_dict_by_test',
  76                         return_value={'run': mock_obj}):
  77             self.assertEqual(self.runner.get_run_dict('test_name'),
  78                              mock_obj)
  79
  80     @mock.patch('functest.ci.run_tests.logger.error')
  81     def test_get_run_dict_if_defined_missing_config_option(self,
  82                                                            mock_logger_error):
  83         with mock.patch('functest.ci.run_tests.'
  84                         'ft_utils.get_dict_by_test',
  85                         return_value=None):
  86             testname = 'test_name'
  87             self.assertEqual(self.runner.get_run_dict(testname),
  88                              None)
  89             mock_logger_error.assert_called_once_with("Cannot get {}'s config "
  90                                                       "options"
  91                                                       .format(testname))
  92
  93         with mock.patch('functest.ci.run_tests.'
  94                         'ft_utils.get_dict_by_test',
  95                         return_value={}):
  96             testname = 'test_name'
  97             self.assertEqual(self.runner.get_run_dict(testname),
  98                              None)
  99
 100     @mock.patch('functest.ci.run_tests.logger.exception')
 101     def test_get_run_dict_if_defined_exception(self,
 102                                                mock_logger_except):
 103         with mock.patch('functest.ci.run_tests.'
 104                         'ft_utils.get_dict_by_test',
 105                         side_effect=Exception):
 106             testname = 'test_name'
 107             self.assertEqual(self.runner.get_run_dict(testname),
 108                              None)
 109             mock_logger_except.assert_called_once_with("Cannot get {}'s config"
 110                                                        " options"
 111                                                        .format(testname))
 112
 113     def test_run_tests_import_test_class_exception(self):
 114         mock_test = mock.Mock()
 115         args = {'get_name.return_value': 'test_name',
 116                 'needs_clean.return_value': False}
 117         mock_test.configure_mock(**args)
 118         with mock.patch('functest.ci.run_tests.Runner.source_rc_file'), \
 119             mock.patch('functest.ci.run_tests.Runner.get_run_dict',
 120                        return_value=None), \
 121                 self.assertRaises(Exception) as context:
 122             self.runner(mock_test, 'tier_name')
 123             msg = "Cannot import the class for the test case."
 124             self.assertTrue(msg in context)
 125
 126     @mock.patch('functest.ci.run_tests.Runner.source_rc_file')
 127     @mock.patch('importlib.import_module', name="module",
 128                 return_value=mock.Mock(test_class=mock.Mock(
 129                     side_effect=FakeModule)))
 130     @mock.patch('functest.utils.functest_utils.get_dict_by_test')
 131     def test_run_tests_default(self, *args):
 132         mock_test = mock.Mock()
 133         kwargs = {'get_name.return_value': 'test_name',
 134                   'needs_clean.return_value': True}
 135         mock_test.configure_mock(**kwargs)
 136         test_run_dict = {'module': 'test_module',
 137                          'class': 'test_class'}
 138         with mock.patch('functest.ci.run_tests.Runner.get_run_dict',
 139                         return_value=test_run_dict):
 140             self.runner.clean_flag = True
 141             self.runner.run_test(mock_test)
 142         self.assertEqual(self.runner.overall_result,
 143                          run_tests.Result.EX_OK)
 144
 145     @mock.patch('functest.ci.run_tests.Runner.run_test',
 146                 return_value=TestCase.EX_OK)
 147     def test_run_tier_default(self, *mock_methods):
 148         self.assertEqual(self.runner.run_tier(self.tier),
 149                          run_tests.Result.EX_OK)
 150         mock_methods[0].assert_called_with(mock.ANY)
 151
 152     @mock.patch('functest.ci.run_tests.logger.info')
 153     def test_run_tier_missing_test(self, mock_logger_info):
 154         self.tier.get_tests.return_value = None
 155         self.assertEqual(self.runner.run_tier(self.tier),
 156                          run_tests.Result.EX_ERROR)
 157         self.assertTrue(mock_logger_info.called)
 158
 159     @mock.patch('functest.ci.run_tests.logger.info')
 160     @mock.patch('functest.ci.run_tests.Runner.run_tier')
 161     @mock.patch('functest.ci.run_tests.Runner.summary')
 162     def test_run_all_default(self, *mock_methods):
 163         CONST.__setattr__('CI_LOOP', 'test_ci_loop')
 164         self.runner.run_all()
 165         mock_methods[1].assert_not_called()
 166         self.assertTrue(mock_methods[2].called)
 167
 168     @mock.patch('functest.ci.run_tests.logger.info')
 169     @mock.patch('functest.ci.run_tests.Runner.summary')
 170     def test_run_all_missing_tier(self, *mock_methods):
 171         CONST.__setattr__('CI_LOOP', 'loop_re_not_available')
 172         self.runner.run_all()
 173         self.assertTrue(mock_methods[1].called)
 174
 175     @mock.patch('functest.ci.run_tests.Runner.source_rc_file',
 176                 side_effect=Exception)
 177     @mock.patch('functest.ci.run_tests.Runner.summary')
 178     def test_main_failed(self, *mock_methods):
 179         kwargs = {'test': 'test_name', 'noclean': True, 'report': True}
 180         args = {'get_tier.return_value': False,
 181                 'get_test.return_value': False}
 182         self.runner._tiers = mock.Mock()
 183         self.runner._tiers.configure_mock(**args)
 184         self.assertEqual(self.runner.main(**kwargs),
 185                          run_tests.Result.EX_ERROR)
 186         mock_methods[1].assert_called_once_with()
 187
 188     @mock.patch('functest.ci.run_tests.Runner.source_rc_file')
 189     @mock.patch('functest.ci.run_tests.Runner.run_test',
 190                 return_value=TestCase.EX_OK)
 191     @mock.patch('functest.ci.run_tests.Runner.summary')
 192     def test_main_tier(self, *mock_methods):
 193         mock_tier = mock.Mock()
 194         args = {'get_name.return_value': 'tier_name',
 195                 'get_tests.return_value': ['test_name']}
 196         mock_tier.configure_mock(**args)
 197         kwargs = {'test': 'tier_name', 'noclean': True, 'report': True}
 198         args = {'get_tier.return_value': mock_tier,
 199                 'get_test.return_value': None}
 200         self.runner._tiers = mock.Mock()
 201         self.runner._tiers.configure_mock(**args)
 202         self.assertEqual(self.runner.main(**kwargs),
 203                          run_tests.Result.EX_OK)
 204         mock_methods[1].assert_called_once_with('test_name')
 205
 206     @mock.patch('functest.ci.run_tests.Runner.source_rc_file')
 207     @mock.patch('functest.ci.run_tests.Runner.run_test',
 208                 return_value=TestCase.EX_OK)
 209     def test_main_test(self, *mock_methods):
 210         kwargs = {'test': 'test_name', 'noclean': True, 'report': True}
 211         args = {'get_tier.return_value': None,
 212                 'get_test.return_value': 'test_name'}
 213         self.runner._tiers = mock.Mock()
 214         self.runner._tiers.configure_mock(**args)
 215         self.assertEqual(self.runner.main(**kwargs),
 216                          run_tests.Result.EX_OK)
 217         mock_methods[0].assert_called_once_with('test_name')
 218
 219     @mock.patch('functest.ci.run_tests.Runner.source_rc_file')
 220     @mock.patch('functest.ci.run_tests.Runner.run_all')
 221     @mock.patch('functest.ci.run_tests.Runner.summary')
 222     def test_main_all_tier(self, *mock_methods):
 223         kwargs = {'test': 'all', 'noclean': True, 'report': True}
 224         args = {'get_tier.return_value': None,
 225                 'get_test.return_value': None}
 226         self.runner._tiers = mock.Mock()
 227         self.runner._tiers.configure_mock(**args)
 228         self.assertEqual(self.runner.main(**kwargs),
 229                          run_tests.Result.EX_OK)
 230         mock_methods[1].assert_called_once_with()
 231
 232     @mock.patch('functest.ci.run_tests.Runner.source_rc_file')
 233     @mock.patch('functest.ci.run_tests.Runner.summary')
 234     def test_main_any_tier_test_ko(self, *mock_methods):
 235         kwargs = {'test': 'any', 'noclean': True, 'report': True}
 236         args = {'get_tier.return_value': None,
 237                 'get_test.return_value': None}
 238         self.runner._tiers = mock.Mock()
 239         self.runner._tiers.configure_mock(**args)
 240         self.assertEqual(self.runner.main(**kwargs),
 241                          run_tests.Result.EX_ERROR)
 242
 243
 244 if __name__ == "__main__":
 245     logging.disable(logging.CRITICAL)
 246     unittest.main(verbosity=2)