Update ODL testcase to Keystone v3
[functest.git] / functest / tests / unit / utils / test_functest_utils.py
index d84a320..17fb4c1 100644 (file)
@@ -8,11 +8,11 @@
 # http://www.apache.org/licenses/LICENSE-2.0
 
 import logging
+import pkg_resources
 import os
 import time
 import unittest
 
-from git.exc import NoSuchPathError
 import mock
 import requests
 from six.moves import urllib
@@ -56,8 +56,8 @@ class FunctestUtilsTesting(unittest.TestCase):
         self.testcase_dict = {'case_name': 'testname',
                               'criteria': self.criteria}
         self.parameter = 'general.openstack.image_name'
-        self.config_yaml = os.path.normpath(os.path.join(os.path.dirname(
-            os.path.abspath(__file__)), '../../../ci/config_functest.yaml'))
+        self.config_yaml = pkg_resources.resource_filename(
+            'functest', 'ci/config_functest.yaml')
         self.db_url_env = 'http://foo/testdb'
         self.testcases_yaml = "test_testcases_yaml"
         self.file_yaml = {'general': {'openstack': {'image_name':
@@ -97,130 +97,30 @@ class FunctestUtilsTesting(unittest.TestCase):
             m.assert_called_once_with(dest, 'wb')
             self.assertTrue(mock_sh.called)
 
-    def test_get_git_branch(self):
-        with mock.patch('functest.utils.functest_utils.Repo') as mock_repo:
-            mock_obj2 = mock.Mock()
-            attrs = {'name': 'test_branch'}
-            mock_obj2.configure_mock(**attrs)
-
-            mock_obj = mock.Mock()
-            attrs = {'active_branch': mock_obj2}
-            mock_obj.configure_mock(**attrs)
-
-            mock_repo.return_value = mock_obj
-            self.assertEqual(functest_utils.get_git_branch(self.repo_path),
-                             'test_branch')
-
-    @mock.patch('functest.utils.functest_utils.Repo',
-                side_effect=NoSuchPathError)
-    def test_get_git_branch_failed(self, mock_repo):
-        self.assertRaises(NoSuchPathError,
-                          lambda: functest_utils.get_git_branch(self.repo_path
-                                                                ))
-
-    @mock.patch('functest.utils.functest_utils.logger.error')
-    def test_get_installer_type_failed(self, mock_logger_error):
-        with mock.patch.dict(os.environ,
-                             {},
-                             clear=True):
-            self.assertEqual(functest_utils.get_installer_type(),
-                             "Unknown_installer")
-            mock_logger_error.assert_called_once_with("Impossible to retrieve"
-                                                      " the installer type")
-
-    def test_get_installer_type_default(self):
-        with mock.patch.dict(os.environ,
-                             {'INSTALLER_TYPE': 'test_installer'},
-                             clear=True):
-            self.assertEqual(functest_utils.get_installer_type(),
-                             self.installer)
-
-    @mock.patch('functest.utils.functest_utils.logger.info')
-    def test_get_scenario_failed(self, mock_logger_info):
-        with mock.patch.dict(os.environ,
-                             {},
-                             clear=True):
-            self.assertEqual(functest_utils.get_scenario(),
-                             "os-nosdn-nofeature-noha")
-            mock_logger_info.assert_called_once_with("Impossible to retrieve "
-                                                     "the scenario.Use "
-                                                     "default "
-                                                     "os-nosdn-nofeature-noha")
-
-    def test_get_scenario_default(self):
-        with mock.patch.dict(os.environ,
-                             {'DEPLOY_SCENARIO': 'test_scenario'},
-                             clear=True):
-            self.assertEqual(functest_utils.get_scenario(),
-                             self.scenario)
-
-    @mock.patch('functest.utils.functest_utils.get_build_tag')
-    def test_get_version_daily_job(self, mock_get_build_tag):
-        mock_get_build_tag.return_value = self.build_tag
+    def test_get_version_daily_job(self):
+        CONST.__setattr__('BUILD_TAG', self.build_tag)
         self.assertEqual(functest_utils.get_version(), self.version)
 
-    @mock.patch('functest.utils.functest_utils.get_build_tag')
-    def test_get_version_weekly_job(self, mock_get_build_tag):
-        mock_get_build_tag.return_value = self.build_tag_week
+    def test_get_version_weekly_job(self):
+        CONST.__setattr__('BUILD_TAG', self.build_tag_week)
         self.assertEqual(functest_utils.get_version(), self.version)
 
-    @mock.patch('functest.utils.functest_utils.get_build_tag')
-    def test_get_version_with_dummy_build_tag(self, mock_get_build_tag):
-        mock_get_build_tag.return_value = 'whatever'
+    def test_get_version_with_dummy_build_tag(self):
+        CONST.__setattr__('BUILD_TAG', 'whatever')
         self.assertEqual(functest_utils.get_version(), 'unknown')
 
-    @mock.patch('functest.utils.functest_utils.get_build_tag')
-    def test_get_version_unknown(self, mock_get_build_tag):
-        mock_get_build_tag.return_value = "unknown_build_tag"
+    def test_get_version_unknown(self):
+        CONST.__setattr__('BUILD_TAG', 'unknown_build_tag')
         self.assertEqual(functest_utils.get_version(), "unknown")
 
-    @mock.patch('functest.utils.functest_utils.logger.info')
-    def test_get_pod_name_failed(self, mock_logger_info):
-        with mock.patch.dict(os.environ,
-                             {},
-                             clear=True):
-            self.assertEqual(functest_utils.get_pod_name(),
-                             "unknown-pod")
-            mock_logger_info.assert_called_once_with("Unable to retrieve "
-                                                     "the POD name from "
-                                                     "environment. Using "
-                                                     "pod name 'unknown-pod'")
-
-    def test_get_pod_name_default(self):
-        with mock.patch.dict(os.environ,
-                             {'NODE_NAME': 'test_node_name'},
-                             clear=True):
-            self.assertEqual(functest_utils.get_pod_name(),
-                             self.node_name)
-
-    @mock.patch('functest.utils.functest_utils.logger.info')
-    def test_get_build_tag_failed(self, mock_logger_info):
-        with mock.patch.dict(os.environ,
-                             {},
-                             clear=True):
-            self.assertEqual(functest_utils.get_build_tag(),
-                             "none")
-            mock_logger_info.assert_called_once_with("Impossible to retrieve"
-                                                     " the build tag")
-
-    def test_get_build_tag_default(self):
-        with mock.patch.dict(os.environ,
-                             {'BUILD_TAG': self.build_tag},
-                             clear=True):
-            self.assertEqual(functest_utils.get_build_tag(),
-                             self.build_tag)
-
     @mock.patch('functest.utils.functest_utils.logger.info')
     def test_logger_test_results(self, mock_logger_info):
         CONST.__setattr__('results_test_db_url', self.db_url)
-        with mock.patch('functest.utils.functest_utils.get_pod_name',
-                        return_value=self.node_name), \
-                mock.patch('functest.utils.functest_utils.get_scenario',
-                           return_value=self.scenario), \
-                mock.patch('functest.utils.functest_utils.get_version',
-                           return_value=self.version), \
-                mock.patch('functest.utils.functest_utils.get_build_tag',
-                           return_value=self.build_tag):
+        CONST.__setattr__('BUILD_TAG', self.build_tag)
+        CONST.__setattr__('NODE_NAME', self.node_name)
+        CONST.__setattr__('DEPLOY_SCENARIO', self.scenario)
+        with mock.patch('functest.utils.functest_utils.get_version',
+                        return_value=self.version):
             functest_utils.logger_test_results(self.project, self.case_name,
                                                self.status, self.details)
             mock_logger_info.assert_called_once_with(
@@ -486,9 +386,7 @@ class FunctestUtilsTesting(unittest.TestCase):
     def test_get_dict_by_test(self, mock_logger_error):
         with mock.patch('six.moves.builtins.open', mock.mock_open()), \
                 mock.patch('functest.utils.functest_utils.yaml.safe_load') \
-                as mock_yaml, \
-                mock.patch('functest.utils.functest_utils.get_testcases_'
-                           'file_dir'):
+                as mock_yaml:
             mock_obj = mock.Mock()
             attrs = {'get.return_value': [{'testcases': [self.testcase_dict]}]}
             mock_obj.configure_mock(**attrs)
@@ -542,16 +440,6 @@ class FunctestUtilsTesting(unittest.TestCase):
                 assert_called_once_with(self.parameter,
                                         self.config_yaml)
 
-    # TODO: merge_dicts
-
-    @mock.patch('functest.utils.functest_utils.get_functest_config')
-    def test_get_testcases_file_dir(self, mock_get_functest_config):
-        mock_get_functest_config.return_value = self.testcases_yaml
-        resp = functest_utils.get_testcases_file_dir()
-        self.assertEqual(resp, self.testcases_yaml)
-        mock_get_functest_config.assert_called_once_with(
-            'general.functest.testcases_yaml')
-
     def test_get_functest_yaml(self):
         with mock.patch('six.moves.builtins.open', mock.mock_open()), \
                 mock.patch('functest.utils.functest_utils.yaml.safe_load') \