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