functest/tests/unit/core/test_testcase.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 """Define the class required to fully cover testcase."""
  11
  12 import logging
  13 import unittest
  14
  15 import mock
  16
  17 from functest.core import testcase
  18
  19 __author__ = "Cedric Ollivier <cedric.ollivier@orange.com>"
  20
  21
  22 class TestCaseTesting(unittest.TestCase):
  23     """The class testing TestCase."""
  24     # pylint: disable=missing-docstring,too-many-public-methods
  25
  26     _case_name = "base"
  27     _project_name = "functest"
  28     _published_result = "PASS"
  29
  30     def setUp(self):
  31         self.test = testcase.TestCase(case_name=self._case_name,
  32                                       project_name=self._project_name)
  33         self.test.start_time = "1"
  34         self.test.stop_time = "2"
  35         self.test.result = 100
  36         self.test.details = {"Hello": "World"}
  37
  38     def test_run_unimplemented(self):
  39         self.assertEqual(self.test.run(),
  40                          testcase.TestCase.EX_RUN_ERROR)
  41
  42     @mock.patch('functest.utils.functest_utils.push_results_to_db',
  43                 return_value=False)
  44     def _test_missing_attribute(self, mock_function=None):
  45         self.assertEqual(self.test.push_to_db(),
  46                          testcase.TestCase.EX_PUSH_TO_DB_ERROR)
  47         mock_function.assert_not_called()
  48
  49     def test_missing_project_name(self):
  50         self.test.project_name = None
  51         self._test_missing_attribute()
  52
  53     def test_missing_case_name(self):
  54         self.test.case_name = None
  55         self._test_missing_attribute()
  56
  57     def test_missing_start_time(self):
  58         self.test.start_time = None
  59         self._test_missing_attribute()
  60
  61     def test_missing_stop_time(self):
  62         self.test.stop_time = None
  63         self._test_missing_attribute()
  64
  65     @mock.patch('functest.utils.functest_utils.push_results_to_db',
  66                 return_value=True)
  67     def test_missing_details(self, mock_function=None):
  68         self.test.details = None
  69         self.assertEqual(self.test.push_to_db(),
  70                          testcase.TestCase.EX_OK)
  71         mock_function.assert_called_once_with(
  72             self._project_name, self._case_name, self.test.start_time,
  73             self.test.stop_time, self._published_result, self.test.details)
  74
  75     @mock.patch('functest.utils.functest_utils.push_results_to_db',
  76                 return_value=False)
  77     def test_push_to_db_failed(self, mock_function=None):
  78         self.assertEqual(self.test.push_to_db(),
  79                          testcase.TestCase.EX_PUSH_TO_DB_ERROR)
  80         mock_function.assert_called_once_with(
  81             self._project_name, self._case_name, self.test.start_time,
  82             self.test.stop_time, self._published_result, self.test.details)
  83
  84     @mock.patch('functest.utils.functest_utils.push_results_to_db',
  85                 return_value=True)
  86     def test_push_to_db(self, mock_function=None):
  87         self.assertEqual(self.test.push_to_db(),
  88                          testcase.TestCase.EX_OK)
  89         mock_function.assert_called_once_with(
  90             self._project_name, self._case_name, self.test.start_time,
  91             self.test.stop_time, self._published_result, self.test.details)
  92
  93     @mock.patch('functest.utils.functest_utils.push_results_to_db',
  94                 return_value=True)
  95     def test_push_to_db_res_ko(self, mock_function=None):
  96         self.test.result = 0
  97         self.assertEqual(self.test.push_to_db(),
  98                          testcase.TestCase.EX_OK)
  99         mock_function.assert_called_once_with(
 100             self._project_name, self._case_name, self.test.start_time,
 101             self.test.stop_time, 'FAIL', self.test.details)
 102
 103     @mock.patch('functest.utils.functest_utils.push_results_to_db',
 104                 return_value=True)
 105     def test_push_to_db_both_ko(self, mock_function=None):
 106         self.test.result = 0
 107         self.test.criteria = 0
 108         self.assertEqual(self.test.push_to_db(),
 109                          testcase.TestCase.EX_OK)
 110         mock_function.assert_called_once_with(
 111             self._project_name, self._case_name, self.test.start_time,
 112             self.test.stop_time, 'FAIL', self.test.details)
 113
 114     def test_check_criteria_missing(self):
 115         self.test.criteria = None
 116         self.assertEqual(self.test.is_successful(),
 117                          testcase.TestCase.EX_TESTCASE_FAILED)
 118
 119     def test_check_result_missing(self):
 120         self.test.result = None
 121         self.assertEqual(self.test.is_successful(),
 122                          testcase.TestCase.EX_TESTCASE_FAILED)
 123
 124     def test_check_result_failed(self):
 125         # Backward compatibility
 126         # It must be removed as soon as TestCase subclasses
 127         # stop setting result = 'PASS' or 'FAIL'.
 128         self.test.result = 'FAIL'
 129         self.assertEqual(self.test.is_successful(),
 130                          testcase.TestCase.EX_TESTCASE_FAILED)
 131
 132     def test_check_result_pass(self):
 133         # Backward compatibility
 134         # It must be removed as soon as TestCase subclasses
 135         # stop setting result = 'PASS' or 'FAIL'.
 136         self.test.result = 'PASS'
 137         self.assertEqual(self.test.is_successful(),
 138                          testcase.TestCase.EX_OK)
 139
 140     def test_check_result_lt(self):
 141         self.test.result = 50
 142         self.assertEqual(self.test.is_successful(),
 143                          testcase.TestCase.EX_TESTCASE_FAILED)
 144
 145     def test_check_result_eq(self):
 146         self.test.result = 100
 147         self.assertEqual(self.test.is_successful(),
 148                          testcase.TestCase.EX_OK)
 149
 150     def test_check_result_gt(self):
 151         self.test.criteria = 50
 152         self.test.result = 100
 153         self.assertEqual(self.test.is_successful(),
 154                          testcase.TestCase.EX_OK)
 155
 156     def test_check_result_zero(self):
 157         self.test.criteria = 0
 158         self.test.result = 0
 159         self.assertEqual(self.test.is_successful(),
 160                          testcase.TestCase.EX_TESTCASE_FAILED)
 161
 162     def test_get_duration_start_ko(self):
 163         self.test.start_time = None
 164         self.assertEqual(self.test.get_duration(), "XX:XX")
 165         self.test.start_time = 0
 166         self.assertEqual(self.test.get_duration(), "XX:XX")
 167
 168     def test_get_duration_end_ko(self):
 169         self.test.stop_time = None
 170         self.assertEqual(self.test.get_duration(), "XX:XX")
 171         self.test.stop_time = 0
 172         self.assertEqual(self.test.get_duration(), "XX:XX")
 173
 174     def test_get_invalid_duration(self):
 175         self.test.start_time = 2
 176         self.test.stop_time = 1
 177         self.assertEqual(self.test.get_duration(), "XX:XX")
 178
 179     def test_get_zero_duration(self):
 180         self.test.start_time = 2
 181         self.test.stop_time = 2
 182         self.assertEqual(self.test.get_duration(), "00:00")
 183
 184     def test_get_duration(self):
 185         self.test.start_time = 1
 186         self.test.stop_time = 180
 187         self.assertEqual(self.test.get_duration(), "02:59")
 188
 189     def test_str_project_name_ko(self):
 190         self.test.project_name = None
 191         self.assertIn("<functest.core.testcase.TestCase object at",
 192                       str(self.test))
 193
 194     def test_str_case_name_ko(self):
 195         self.test.case_name = None
 196         self.assertIn("<functest.core.testcase.TestCase object at",
 197                       str(self.test))
 198
 199     def test_str_pass(self):
 200         duration = '01:01'
 201         with mock.patch.object(self.test, 'get_duration',
 202                                return_value=duration), \
 203                 mock.patch.object(self.test, 'is_successful',
 204                                   return_value=testcase.TestCase.EX_OK):
 205             message = str(self.test)
 206         self.assertIn(self._project_name, message)
 207         self.assertIn(self._case_name, message)
 208         self.assertIn(duration, message)
 209         self.assertIn('PASS', message)
 210
 211     def test_str_fail(self):
 212         duration = '00:59'
 213         with mock.patch.object(self.test, 'get_duration',
 214                                return_value=duration), \
 215                 mock.patch.object(
 216                     self.test, 'is_successful',
 217                     return_value=testcase.TestCase.EX_TESTCASE_FAILED):
 218             message = str(self.test)
 219         self.assertIn(self._project_name, message)
 220         self.assertIn(self._case_name, message)
 221         self.assertIn(duration, message)
 222         self.assertIn('FAIL', message)
 223
 224     def test_create_snapshot(self):
 225         self.assertEqual(self.test.create_snapshot(),
 226                          testcase.TestCase.EX_OK)
 227
 228     def test_clean(self):
 229         self.assertEqual(self.test.clean(), None)
 230
 231
 232 class OSGCTestCaseTesting(unittest.TestCase):
 233     """The class testing OSGCTestCase."""
 234     # pylint: disable=missing-docstring
 235
 236     def setUp(self):
 237         self.test = testcase.OSGCTestCase()
 238
 239     @mock.patch('functest.utils.openstack_snapshot.main',
 240                 side_effect=Exception)
 241     def test_create_snapshot_exc(self, mock_method=None):
 242         self.assertEqual(self.test.create_snapshot(),
 243                          testcase.TestCase.EX_RUN_ERROR)
 244         mock_method.assert_called_once_with()
 245
 246     @mock.patch('functest.utils.openstack_snapshot.main', return_value=-1)
 247     def test_create_snapshot_ko(self, mock_method=None):
 248         self.assertEqual(self.test.create_snapshot(),
 249                          testcase.TestCase.EX_RUN_ERROR)
 250         mock_method.assert_called_once_with()
 251
 252     @mock.patch('functest.utils.openstack_snapshot.main', return_value=0)
 253     def test_create_snapshot_env(self, mock_method=None):
 254         self.assertEqual(self.test.create_snapshot(),
 255                          testcase.TestCase.EX_OK)
 256         mock_method.assert_called_once_with()
 257
 258     @mock.patch('functest.utils.openstack_clean.main', side_effect=Exception)
 259     def test_clean_exc(self, mock_method=None):
 260         self.assertEqual(self.test.clean(), None)
 261         mock_method.assert_called_once_with()
 262
 263     @mock.patch('functest.utils.openstack_clean.main', return_value=-1)
 264     def test_clean_ko(self, mock_method=None):
 265         self.assertEqual(self.test.clean(), None)
 266         mock_method.assert_called_once_with()
 267
 268     @mock.patch('functest.utils.openstack_clean.main', return_value=0)
 269     def test_clean(self, mock_method=None):
 270         self.assertEqual(self.test.clean(), None)
 271         mock_method.assert_called_once_with()
 272
 273
 274 if __name__ == "__main__":
 275     logging.disable(logging.CRITICAL)
 276     unittest.main(verbosity=2)