Avoid side effects induced by functest_constants in ODL UT

It partially reverts [1] (odl.py + test_odl.py).

[1] https://gerrit.opnfv.org/gerrit/#/c/24619/

Change-Id: Ie51ccf10f8ffa0a63086796f8bb722ef50567b2d
Signed-off-by: Cédric Ollivier <cedric.ollivier@orange.com>

3 files changed, 57 insertions, 71 deletions

diff --git a/functest/opnfv_tests/sdn/odl/odl.py b/functest/opnfv_tests/sdn/odl/odl.py
index 7f44ae69c..706b0dad8 100755
--- a/functest/opnfv_tests/sdn/odl/odl.py
+++ b/functest/opnfv_tests/sdn/odl/odl.py
@@ -20,10 +20,9 @@ from robot.errors import RobotError
 import robot.run
 from robot.utils.robottime import timestamp_to_secs
 
-import functest.core.testcase_base as testcase_base
+from functest.core import testcase_base
 import functest.utils.functest_logger as ft_logger
 import functest.utils.openstack_utils as op_utils
-import functest.utils.functest_constants as ft_constants
 
 
 class ODLResultVisitor(ResultVisitor):
@@ -49,14 +48,13 @@ class ODLResultVisitor(ResultVisitor):
 
 class ODLTests(testcase_base.TestcaseBase):
 
-    repos = ft_constants.REPOS_DIR
+    repos = "/home/opnfv/repos/"
     odl_test_repo = os.path.join(repos, "odl_test")
     neutron_suite_dir = os.path.join(odl_test_repo,
                                      "csit/suites/openstack/neutron")
     basic_suite_dir = os.path.join(odl_test_repo,
                                    "csit/suites/integration/basic")
-    res_dir = os.path.join(ft_constants.FUNCTEST_RESULTS_DIR, "odl")
-
+    res_dir = '/home/opnfv/functest/results/odl/'
     logger = ft_logger.Logger("opendaylight").getLogger()
 
     def __init__(self):
@@ -80,8 +78,8 @@ class ODLTests(testcase_base.TestcaseBase):
             return False
 
     def parse_results(self):
-        output_dir = os.path.join(self.res_dir, 'output.xml')
-        result = ExecutionResult(output_dir)
+        xml_file = os.path.join(self.res_dir, 'output.xml')
+        result = ExecutionResult(xml_file)
         visitor = ODLResultVisitor()
         result.visit(visitor)
         self.criteria = result.suite.status
@@ -153,29 +151,23 @@ class ODLTests(testcase_base.TestcaseBase):
             kwargs['odlrestconfport'] = '8181'
             kwargs['odlusername'] = 'admin'
             kwargs['odlpassword'] = 'admin'
-
-            installer_type = ft_constants.CI_INSTALLER_TYPE
-            kwargs['osusername'] = ft_constants.OS_USERNAME
-            kwargs['ostenantname'] = ft_constants.OS_TENANT_NAME
-            kwargs['ospassword'] = ft_constants.OS_PASSWORD
-
+            installer_type = None
+            if 'INSTALLER_TYPE' in os.environ:
+                installer_type = os.environ['INSTALLER_TYPE']
+            kwargs['osusername'] = os.environ['OS_USERNAME']
+            kwargs['ostenantname'] = os.environ['OS_TENANT_NAME']
+            kwargs['ospassword'] = os.environ['OS_PASSWORD']
             if installer_type == 'fuel':
                 kwargs['odlwebport'] = '8282'
             elif installer_type == 'apex':
-                if ft_constants.SDN_CONTROLLER_IP is None:
-                    return self.EX_RUN_ERROR
-                kwargs['odlip'] = ft_constants.SDN_CONTROLLER_IP
+                kwargs['odlip'] = os.environ['SDN_CONTROLLER_IP']
                 kwargs['odlwebport'] = '8181'
             elif installer_type == 'joid':
-                if ft_constants.SDN_CONTROLLER is None:
-                    return self.EX_RUN_ERROR
-                kwargs['odlip'] = ft_constants.SDN_CONTROLLER
+                kwargs['odlip'] = os.environ['SDN_CONTROLLER']
             elif installer_type == 'compass':
                 kwargs['odlwebport'] = '8181'
             else:
-                if ft_constants.SDN_CONTROLLER_IP is None:
-                    return self.EX_RUN_ERROR
-                kwargs['odlip'] = ft_constants.SDN_CONTROLLER_IP
+                kwargs['odlip'] = os.environ['SDN_CONTROLLER_IP']
         except KeyError as e:
             self.logger.error("Cannot run ODL testcases. "
                               "Please check env var: "
diff --git a/functest/tests/unit/core/test_testcase_base.py b/functest/tests/unit/core/test_testcase_base.py
index 181eed94b..b7c81d87c 100644
--- a/functest/tests/unit/core/test_testcase_base.py
+++ b/functest/tests/unit/core/test_testcase_base.py
@@ -11,7 +11,7 @@ import logging
 import mock
 import unittest
 
-import functest.core.testcase_base as testcase_base
+from functest.core import testcase_base
 
 
 class TestcaseBaseTesting(unittest.TestCase):
diff --git a/functest/tests/unit/odl/test_odl.py b/functest/tests/unit/odl/test_odl.py
index 9a63ffb01..0deef6bde 100644
--- a/functest/tests/unit/odl/test_odl.py
+++ b/functest/tests/unit/odl/test_odl.py
@@ -15,9 +15,8 @@ import unittest
 
 from robot.errors import RobotError
 
-import functest.core.testcase_base as testcase_base
+from functest.core import testcase_base
 from functest.opnfv_tests.sdn.odl import odl
-from functest.utils import functest_constants as ft_constants
 
 
 class ODLTesting(unittest.TestCase):
@@ -36,9 +35,12 @@ class ODLTesting(unittest.TestCase):
     _odl_password = "admin"
 
     def setUp(self):
-        ft_constants.OS_USERNAME = self._os_username
-        ft_constants.OS_PASSWORD = self._os_password
-        ft_constants.OS_TENANT_NAME = self._os_tenantname
+        for var in ("INSTALLER_TYPE", "SDN_CONTROLLER", "SDN_CONTROLLER_IP"):
+            if var in os.environ:
+                del os.environ[var]
+        os.environ["OS_USERNAME"] = self._os_username
+        os.environ["OS_PASSWORD"] = self._os_password
+        os.environ["OS_TENANT_NAME"] = self._os_tenantname
         self.test = odl.ODLTests()
 
     @mock.patch('fileinput.input', side_effect=Exception())
@@ -77,9 +79,9 @@ class ODLTesting(unittest.TestCase):
     def _test_main(self, status, *args):
         kwargs = self._get_main_kwargs()
         self.assertEqual(self.test.main(**kwargs), status)
-        odl_res_dir = odl.ODLTests.res_dir
         if len(args) > 0:
-            args[0].assert_called_once_with(odl_res_dir)
+            args[0].assert_called_once_with(
+                odl.ODLTests.res_dir)
         if len(args) > 1:
             variable = ['KEYSTONE:{}'.format(self._keystone_ip),
                         'NEUTRON:{}'.format(self._neutron_ip),
@@ -89,18 +91,17 @@ class ODLTesting(unittest.TestCase):
                         'ODL_SYSTEM_IP:{}'.format(self._sdn_controller_ip),
                         'PORT:{}'.format(self._odl_webport),
                         'RESTCONFPORT:{}'.format(self._odl_restconfport)]
-            output_file = os.path.join(odl_res_dir, 'output.xml')
             args[1].assert_called_once_with(
                 odl.ODLTests.basic_suite_dir,
                 odl.ODLTests.neutron_suite_dir,
                 log='NONE',
-                output=output_file,
+                output=os.path.join(odl.ODLTests.res_dir, 'output.xml'),
                 report='NONE',
                 stdout=mock.ANY,
                 variable=variable)
         if len(args) > 2:
-            stdout_file = os.path.join(odl_res_dir, 'stdout.txt')
-            args[2].assert_called_with(stdout_file)
+            args[2].assert_called_with(
+                os.path.join(odl.ODLTests.res_dir, 'stdout.txt'))
 
     def _test_main_missing_keyword(self, key):
         kwargs = self._get_main_kwargs(key)
@@ -223,21 +224,16 @@ class ODLTesting(unittest.TestCase):
             self._test_main(testcase_base.TestcaseBase.EX_OK, *args)
 
     def _test_run_missing_env_var(self, var):
-        if var == 'OS_USERNAME':
-            ft_constants.OS_USERNAME = None
-        elif var == 'OS_PASSWORD':
-            ft_constants.OS_PASSWORD = None
-        elif var == 'OS_TENANT_NAME':
-            ft_constants.OS_TENANT_NAME = None
-
-        self.assertEqual(self.test.run(),
-                         testcase_base.TestcaseBase.EX_RUN_ERROR)
+        with mock.patch('functest.utils.openstack_utils.get_endpoint',
+                        side_effect=self._fake_url_for):
+            del os.environ[var]
+            self.assertEqual(self.test.run(),
+                             testcase_base.TestcaseBase.EX_RUN_ERROR)
 
     def _test_run(self, status=testcase_base.TestcaseBase.EX_OK,
                   exception=None, odlip="127.0.0.3", odlwebport="8080"):
         with mock.patch('functest.utils.openstack_utils.get_endpoint',
-                        side_effect=[self._fake_url_for('identity'),
-                                     self._fake_url_for('network')]):
+                        side_effect=self._fake_url_for):
             if exception:
                 self.test.main = mock.Mock(side_effect=exception)
             else:
@@ -261,66 +257,64 @@ class ODLTesting(unittest.TestCase):
         self._test_run_missing_env_var("OS_TENANT_NAME")
 
     def test_run_main_false(self):
-        ft_constants.CI_INSTALLER_TYPE = None
-        ft_constants.SDN_CONTROLLER_IP = self._sdn_controller_ip
+        os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
         self._test_run(testcase_base.TestcaseBase.EX_RUN_ERROR,
                        odlip=self._sdn_controller_ip,
                        odlwebport=self._odl_webport)
 
     def test_run_main_exception(self):
-        ft_constants.CI_INSTALLER_TYPE = None
-        ft_constants.SDN_CONTROLLER_IP = self._sdn_controller_ip
         with self.assertRaises(Exception):
+            os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
             self._test_run(status=testcase_base.TestcaseBase.EX_RUN_ERROR,
                            exception=Exception(),
                            odlip=self._sdn_controller_ip,
                            odlwebport=self._odl_webport)
 
     def test_run_missing_sdn_controller_ip(self):
-        ft_constants.CI_INSTALLER_TYPE = None
-        ft_constants.SDN_CONTROLLER_IP = None
-        self.assertEqual(self.test.run(),
-                         testcase_base.TestcaseBase.EX_RUN_ERROR)
+        with mock.patch('functest.utils.openstack_utils.get_endpoint',
+                        side_effect=self._fake_url_for):
+            self.assertEqual(self.test.run(),
+                             testcase_base.TestcaseBase.EX_RUN_ERROR)
 
     def test_run_without_installer_type(self):
-        ft_constants.SDN_CONTROLLER_IP = self._sdn_controller_ip
-        ft_constants.CI_INSTALLER_TYPE = None
+        os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
         self._test_run(testcase_base.TestcaseBase.EX_OK,
                        odlip=self._sdn_controller_ip,
                        odlwebport=self._odl_webport)
 
     def test_run_fuel(self):
-        ft_constants.CI_INSTALLER_TYPE = "fuel"
+        os.environ["INSTALLER_TYPE"] = "fuel"
         self._test_run(testcase_base.TestcaseBase.EX_OK,
                        odlip=self._neutron_ip, odlwebport='8282')
 
     def test_run_apex_missing_sdn_controller_ip(self):
-        ft_constants.CI_INSTALLER_TYPE = "apex"
-        ft_constants.SDN_CONTROLLER_IP = None
-        self.assertEqual(self.test.run(),
-                         testcase_base.TestcaseBase.EX_RUN_ERROR)
+        with mock.patch('functest.utils.openstack_utils.get_endpoint',
+                        side_effect=self._fake_url_for):
+            os.environ["INSTALLER_TYPE"] = "apex"
+            self.assertEqual(self.test.run(),
+                             testcase_base.TestcaseBase.EX_RUN_ERROR)
 
     def test_run_apex(self):
-        ft_constants.SDN_CONTROLLER_IP = self._sdn_controller_ip
-        ft_constants.CI_INSTALLER_TYPE = "apex"
+        os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
+        os.environ["INSTALLER_TYPE"] = "apex"
         self._test_run(testcase_base.TestcaseBase.EX_OK,
                        odlip=self._sdn_controller_ip, odlwebport='8181')
 
     def test_run_joid_missing_sdn_controller(self):
-        ft_constants.CI_INSTALLER_TYPE = "joid"
-        ft_constants.SDN_CONTROLLER = None
-        self.assertEqual(self.test.run(),
-                         testcase_base.TestcaseBase.EX_RUN_ERROR)
+        with mock.patch('functest.utils.openstack_utils.get_endpoint',
+                        side_effect=self._fake_url_for):
+            os.environ["INSTALLER_TYPE"] = "joid"
+            self.assertEqual(self.test.run(),
+                             testcase_base.TestcaseBase.EX_RUN_ERROR)
 
     def test_run_joid(self):
-        ft_constants.SDN_CONTROLLER = self._sdn_controller_ip
-        ft_constants.CI_INSTALLER_TYPE = "joid"
+        os.environ["SDN_CONTROLLER"] = self._sdn_controller_ip
+        os.environ["INSTALLER_TYPE"] = "joid"
         self._test_run(testcase_base.TestcaseBase.EX_OK,
-                       odlip=self._sdn_controller_ip,
-                       odlwebport=self._odl_webport)
+                       odlip=self._sdn_controller_ip, odlwebport='8080')
 
     def test_run_compass(self, *args):
-        ft_constants.CI_INSTALLER_TYPE = "compass"
+        os.environ["INSTALLER_TYPE"] = "compass"
         self._test_run(testcase_base.TestcaseBase.EX_OK,
                        odlip=self._neutron_ip, odlwebport='8181')