summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rwxr-xr-xfunctest/ci/generate_report.py4
-rwxr-xr-xfunctest/ci/testcases.yaml2
-rwxr-xr-xfunctest/opnfv_tests/openstack/refstack_client/refstack_client.py86
-rw-r--r--functest/opnfv_tests/openstack/tempest/conf_utils.py2
-rw-r--r--functest/tests/unit/ci/test_generate_report.py129
-rw-r--r--functest/tests/unit/ci/test_run_tests.py192
-rw-r--r--functest/tests/unit/ci/test_tier_builder.py83
-rw-r--r--functest/tests/unit/ci/test_tier_handler.py128
-rw-r--r--functest/tests/unit/opnfv_tests/openstack/refstack_client/test_refstack_client.py11
-rw-r--r--functest/tests/unit/utils/test_functest_utils.py12
-rw-r--r--functest/utils/functest_utils.py10
11 files changed, 642 insertions, 17 deletions
diff --git a/functest/ci/generate_report.py b/functest/ci/generate_report.py
index 89d8fc628..3872a07ed 100755
--- a/functest/ci/generate_report.py
+++ b/functest/ci/generate_report.py
@@ -26,7 +26,7 @@ COL_5_LEN = 75
logger = ft_logger.Logger("generate_report").getLogger()
-def init(tiers_to_run):
+def init(tiers_to_run=[]):
test_cases_arr = []
for tier in tiers_to_run:
for test in tier.get_tests():
@@ -91,7 +91,7 @@ def print_separator(char="=", delimiter="+"):
return str
-def main(args):
+def main(args=[]):
executed_test_cases = args
if CONST.IS_CI_RUN:
diff --git a/functest/ci/testcases.yaml b/functest/ci/testcases.yaml
index bfbc3fdb0..e3d5ffad1 100755
--- a/functest/ci/testcases.yaml
+++ b/functest/ci/testcases.yaml
@@ -132,7 +132,7 @@ tiers:
-
name: refstack_defcore
- criteria: 'success_rate == 100%'
+ criteria: 'success_rate >= 80%'
blocking: false
clean_flag: false
description: >-
diff --git a/functest/opnfv_tests/openstack/refstack_client/refstack_client.py b/functest/opnfv_tests/openstack/refstack_client/refstack_client.py
index d388dcd7d..c9f0f2752 100755
--- a/functest/opnfv_tests/openstack/refstack_client/refstack_client.py
+++ b/functest/opnfv_tests/openstack/refstack_client/refstack_client.py
@@ -7,7 +7,10 @@
# http://www.apache.org/licenses/LICENSE-2.0
import argparse
import os
+import re
import sys
+import subprocess
+import time
from functest.core import testcase_base
from functest.opnfv_tests.openstack.tempest import conf_utils
@@ -24,6 +27,7 @@ class RefstackClient(testcase_base.TestcaseBase):
def __init__(self):
super(RefstackClient, self).__init__()
+ self.case_name = "refstack_defcore"
self.FUNCTEST_TEST = CONST.dir_functest_test
self.CONF_PATH = CONST.refstack_tempest_conf_path
self.DEFCORE_LIST = CONST.refstack_defcore_list
@@ -63,7 +67,80 @@ class RefstackClient(testcase_base.TestcaseBase):
"cd -;".format(CONST.dir_refstack_client,
self.confpath,
self.defcorelist))
- ft_utils.execute_command(cmd)
+ logger.info("Starting Refstack_defcore test case: '%s'." % cmd)
+
+ header = ("Tempest environment:\n"
+ " Installer: %s\n Scenario: %s\n Node: %s\n Date: %s\n" %
+ (CONST.INSTALLER_TYPE,
+ CONST.DEPLOY_SCENARIO,
+ CONST.NODE_NAME,
+ time.strftime("%a %b %d %H:%M:%S %Z %Y")))
+
+ f_stdout = open(
+ os.path.join(conf_utils.REFSTACK_RESULTS_DIR,
+ "refstack.log"), 'w+')
+ f_stderr = open(
+ os.path.join(conf_utils.REFSTACK_RESULTS_DIR,
+ "refstack-error.log"), 'w+')
+ f_env = open(os.path.join(conf_utils.REFSTACK_RESULTS_DIR,
+ "environment.log"), 'w+')
+ f_env.write(header)
+
+ p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
+ stderr=f_stderr, bufsize=1)
+
+ with p.stdout:
+ for line in iter(p.stdout.readline, b''):
+ if 'Tests' in line:
+ break
+ logger.info(line.replace('\n', ''))
+ f_stdout.write(line)
+ p.wait()
+
+ f_stdout.close()
+ f_stderr.close()
+ f_env.close()
+
+ def parse_refstack_result(self):
+ try:
+ with open(os.path.join(conf_utils.REFSTACK_RESULTS_DIR,
+ "refstack.log"), 'r') as logfile:
+ output = logfile.read()
+
+ for match in re.findall("Ran: (\d+) tests in (\d+\.\d{4}) sec.",
+ output):
+ num_tests = match[0]
+ for match in re.findall("- Passed: (\d+)", output):
+ num_success = match
+ for match in re.findall("- Skipped: (\d+)", output):
+ num_skipped = match
+ for match in re.findall("- Failed: (\d+)", output):
+ num_failures = match
+ success_testcases = ""
+ for match in re.findall(r"\{0\}(.*?)[. ]*ok", output):
+ success_testcases += match + ", "
+ failed_testcases = ""
+ for match in re.findall(r"\{0\}(.*?)[. ]*FAILED", output):
+ failed_testcases += match + ", "
+ skipped_testcases = ""
+ for match in re.findall(r"\{0\}(.*?)[. ]*SKIPPED:", output):
+ skipped_testcases += match + ", "
+
+ num_executed = int(num_tests) - int(num_skipped)
+ success_rate = 100 * int(num_success) / int(num_executed)
+
+ self.details = {"num_tests": int(num_tests),
+ "num_failures": int(num_failures),
+ "success": success_testcases,
+ "failed": failed_testcases,
+ "skipped": skipped_testcases}
+ except Exception:
+ success_rate = 0
+
+ self.criteria = ft_utils.check_success_rate(
+ self.case_name, success_rate)
+ logger.info("Testcase %s success_rate is %s%%, is marked as %s"
+ % (self.case_name, success_rate, self.criteria))
def defcore_env_prepare(self):
try:
@@ -80,14 +157,21 @@ class RefstackClient(testcase_base.TestcaseBase):
return res
def run(self):
+ self.start_time = time.time()
+
+ if not os.path.exists(conf_utils.REFSTACK_RESULTS_DIR):
+ os.makedirs(conf_utils.REFSTACK_RESULTS_DIR)
+
try:
self.defcore_env_prepare()
self.run_defcore_default()
+ self.parse_refstack_result()
res = testcase_base.TestcaseBase.EX_OK
except Exception as e:
logger.error('Error with run: %s', e)
res = testcase_base.TestcaseBase.EX_RUN_ERROR
+ self.stop_time = time.time()
return res
def main(self, **kwargs):
diff --git a/functest/opnfv_tests/openstack/tempest/conf_utils.py b/functest/opnfv_tests/openstack/tempest/conf_utils.py
index 185499749..a21322d86 100644
--- a/functest/opnfv_tests/openstack/tempest/conf_utils.py
+++ b/functest/opnfv_tests/openstack/tempest/conf_utils.py
@@ -35,6 +35,8 @@ TEMPEST_DEFCORE = os.path.join(REPO_PATH, TEMPEST_TEST_LIST_DIR,
'defcore_req.txt')
TEMPEST_RAW_LIST = os.path.join(TEMPEST_RESULTS_DIR, 'test_raw_list.txt')
TEMPEST_LIST = os.path.join(TEMPEST_RESULTS_DIR, 'test_list.txt')
+REFSTACK_RESULTS_DIR = os.path.join(CONST.dir_results,
+ 'refstack')
CI_INSTALLER_TYPE = CONST.INSTALLER_TYPE
CI_INSTALLER_IP = CONST.INSTALLER_IP
diff --git a/functest/tests/unit/ci/test_generate_report.py b/functest/tests/unit/ci/test_generate_report.py
new file mode 100644
index 000000000..2225586f2
--- /dev/null
+++ b/functest/tests/unit/ci/test_generate_report.py
@@ -0,0 +1,129 @@
+#!/usr/bin/env python
+
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+
+import logging
+import unittest
+import urllib2
+
+import mock
+
+from functest.ci import generate_report as gen_report
+from functest.tests.unit import test_utils
+from functest.utils import functest_utils as ft_utils
+from functest.utils.constants import CONST
+
+
+class GenerateReportTesting(unittest.TestCase):
+
+ logging.disable(logging.CRITICAL)
+
+ def test_init(self):
+ test_array = gen_report.init()
+ self.assertEqual(test_array, [])
+
+ @mock.patch('functest.ci.generate_report.urllib2.urlopen',
+ side_effect=urllib2.URLError('no host given'))
+ def test_get_results_from_db_fail(self, mock_method):
+ url = "%s/results?build_tag=%s" % (ft_utils.get_db_url(),
+ CONST.BUILD_TAG)
+ self.assertIsNone(gen_report.get_results_from_db())
+ mock_method.assert_called_once_with(url)
+
+ @mock.patch('functest.ci.generate_report.urllib2.urlopen',
+ return_value={'results': []})
+ def test_get_results_from_db_success(self, mock_method):
+ url = "%s/results?build_tag=%s" % (ft_utils.get_db_url(),
+ CONST.BUILD_TAG)
+ self.assertEqual(gen_report.get_results_from_db(), None)
+ mock_method.assert_called_once_with(url)
+
+ def test_get_data(self):
+ self.assertIsInstance(gen_report.get_data({'result': ''}, ''), dict)
+
+ def test_print_line_with_ci_run(self):
+ CONST.IS_CI_RUN = True
+ w1 = 'test_print_line'
+ test_str = ("| %s| %s| %s| %s| %s|\n"
+ % (w1.ljust(gen_report.COL_1_LEN - 1),
+ ''.ljust(gen_report.COL_2_LEN - 1),
+ ''.ljust(gen_report.COL_3_LEN - 1),
+ ''.ljust(gen_report.COL_4_LEN - 1),
+ ''.ljust(gen_report.COL_5_LEN - 1)))
+ self.assertEqual(gen_report.print_line(w1), test_str)
+
+ def test_print_line_without_ci_run(self):
+ CONST.IS_CI_RUN = False
+ w1 = 'test_print_line'
+ test_str = ("| %s| %s| %s| %s|\n"
+ % (w1.ljust(gen_report.COL_1_LEN - 1),
+ ''.ljust(gen_report.COL_2_LEN - 1),
+ ''.ljust(gen_report.COL_3_LEN - 1),
+ ''.ljust(gen_report.COL_4_LEN - 1)))
+ self.assertEqual(gen_report.print_line(w1), test_str)
+
+ def test_print_line_no_column_with_ci_run(self):
+ CONST.IS_CI_RUN = True
+ TOTAL_LEN = gen_report.COL_1_LEN + gen_report.COL_2_LEN
+ TOTAL_LEN += gen_report.COL_3_LEN + gen_report.COL_4_LEN + 2
+ TOTAL_LEN += gen_report.COL_5_LEN + 1
+ test_str = ("| %s|\n" % 'test'.ljust(TOTAL_LEN))
+ self.assertEqual(gen_report.print_line_no_columns('test'), test_str)
+
+ def test_print_line_no_column_without_ci_run(self):
+ CONST.IS_CI_RUN = False
+ TOTAL_LEN = gen_report.COL_1_LEN + gen_report.COL_2_LEN
+ TOTAL_LEN += gen_report.COL_3_LEN + gen_report.COL_4_LEN + 2
+ test_str = ("| %s|\n" % 'test'.ljust(TOTAL_LEN))
+ self.assertEqual(gen_report.print_line_no_columns('test'), test_str)
+
+ def test_print_separator_with_ci_run(self):
+ CONST.IS_CI_RUN = True
+ test_str = ("+" + "=" * gen_report.COL_1_LEN +
+ "+" + "=" * gen_report.COL_2_LEN +
+ "+" + "=" * gen_report.COL_3_LEN +
+ "+" + "=" * gen_report.COL_4_LEN +
+ "+" + "=" * gen_report.COL_5_LEN)
+ test_str += '+\n'
+ self.assertEqual(gen_report.print_separator(), test_str)
+
+ def test_print_separator_without_ci_run(self):
+ CONST.IS_CI_RUN = False
+ test_str = ("+" + "=" * gen_report.COL_1_LEN +
+ "+" + "=" * gen_report.COL_2_LEN +
+ "+" + "=" * gen_report.COL_3_LEN +
+ "+" + "=" * gen_report.COL_4_LEN)
+ test_str += "+\n"
+ self.assertEqual(gen_report.print_separator(), test_str)
+
+ @mock.patch('functest.ci.generate_report.logger.info')
+ def test_main_with_ci_run(self, mock_method):
+ CONST.IS_CI_RUN = True
+ gen_report.main()
+ mock_method.assert_called_once_with(test_utils.SubstrMatch('URL'))
+
+ @mock.patch('functest.ci.generate_report.logger.info')
+ def test_main_with_ci_loop(self, mock_method):
+ CONST.CI_LOOP = 'daily'
+ gen_report.main()
+ mock_method.assert_called_once_with(test_utils.SubstrMatch('CI LOOP'))
+
+ @mock.patch('functest.ci.generate_report.logger.info')
+ def test_main_with_scenario(self, mock_method):
+ CONST.DEPLOY_SCENARIO = 'test_scenario'
+ gen_report.main()
+ mock_method.assert_called_once_with(test_utils.SubstrMatch('SCENARIO'))
+
+ @mock.patch('functest.ci.generate_report.logger.info')
+ def test_main_with_build_tag(self, mock_method):
+ CONST.BUILD_TAG = 'test_build_tag'
+ gen_report.main()
+ mock_method.assert_called_once_with(test_utils.
+ SubstrMatch('BUILD TAG'))
+
+
+if __name__ == "__main__":
+ unittest.main(verbosity=2)
diff --git a/functest/tests/unit/ci/test_run_tests.py b/functest/tests/unit/ci/test_run_tests.py
new file mode 100644
index 000000000..021406109
--- /dev/null
+++ b/functest/tests/unit/ci/test_run_tests.py
@@ -0,0 +1,192 @@
+#!/usr/bin/env python
+
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+
+
+import unittest
+import logging
+
+import mock
+
+from functest.ci import run_tests
+from functest.utils.constants import CONST
+
+
+class RunTestsTesting(unittest.TestCase):
+
+ logging.disable(logging.CRITICAL)
+
+ def setUp(self):
+ self.sep = 'test_sep'
+ self.creds = {'OS_AUTH_URL': 'http://test_ip:test_port/v2.0',
+ 'OS_USERNAME': 'test_os_username',
+ 'OS_TENANT_NAME': 'test_tenant',
+ 'OS_PASSWORD': 'test_password'}
+ self.test = {'test_name': 'test_name'}
+ self.tier = mock.Mock()
+ attrs = {'get_name.return_value': 'test_tier',
+ 'get_tests.return_value': ['test1', 'test2'],
+ 'get_ci_loop.return_value': 'test_ci_loop',
+ 'get_test_names.return_value': ['test1', 'test2']}
+ self.tier.configure_mock(**attrs)
+
+ self.tiers = mock.Mock()
+ attrs = {'get_tiers.return_value': [self.tier]}
+ self.tiers.configure_mock(**attrs)
+
+ @mock.patch('functest.ci.run_tests.logger.info')
+ def test_print_separator(self, mock_logger_info):
+ run_tests.print_separator(self.sep)
+ mock_logger_info.assert_called_once_with(self.sep * 44)
+
+ @mock.patch('functest.ci.run_tests.logger.error')
+ def test_source_rc_file_missing_file(self, mock_logger_error):
+ with mock.patch('functest.ci.run_tests.os.path.isfile',
+ return_value=False), \
+ self.assertRaises(Exception):
+ run_tests.source_rc_file()
+
+ @mock.patch('functest.ci.run_tests.logger.debug')
+ def test_source_rc_file_default(self, mock_logger_debug):
+ with mock.patch('functest.ci.run_tests.os.path.isfile',
+ return_value=True), \
+ mock.patch('functest.ci.run_tests.os_utils.source_credentials',
+ return_value=self.creds):
+ run_tests.source_rc_file()
+
+ @mock.patch('functest.ci.run_tests.os_snapshot.main')
+ def test_generate_os_snapshot(self, mock_os_snap):
+ run_tests.generate_os_snapshot()
+ self.assertTrue(mock_os_snap.called)
+
+ @mock.patch('functest.ci.run_tests.os_clean.main')
+ def test_cleanup(self, mock_os_clean):
+ run_tests.cleanup()
+ self.assertTrue(mock_os_clean.called)
+
+ def test_update_test_info(self):
+ run_tests.GlobalVariables.EXECUTED_TEST_CASES = [self.test]
+ run_tests.update_test_info('test_name',
+ 'test_result',
+ 'test_duration')
+ exp = self.test
+ exp.update({"result": 'test_result',
+ "duration": 'test_duration'})
+ self.assertEqual(run_tests.GlobalVariables.EXECUTED_TEST_CASES,
+ [exp])
+
+ def test_get_run_dict_if_defined_default(self):
+ mock_obj = mock.Mock()
+ with mock.patch('functest.ci.run_tests.'
+ 'ft_utils.get_dict_by_test',
+ return_value={'run': mock_obj}):
+ self.assertEqual(run_tests.get_run_dict('test_name'),
+ mock_obj)
+
+ @mock.patch('functest.ci.run_tests.logger.error')
+ def test_get_run_dict_if_defined_missing_config_option(self,
+ mock_logger_error):
+ with mock.patch('functest.ci.run_tests.'
+ 'ft_utils.get_dict_by_test',
+ return_value=None):
+ testname = 'test_name'
+ self.assertEqual(run_tests.get_run_dict(testname),
+ None)
+ mock_logger_error.assert_called_once_with("Cannot get {}'s config "
+ "options"
+ .format(testname))
+
+ with mock.patch('functest.ci.run_tests.'
+ 'ft_utils.get_dict_by_test',
+ return_value={}):
+ testname = 'test_name'
+ self.assertEqual(run_tests.get_run_dict(testname),
+ None)
+
+ @mock.patch('functest.ci.run_tests.logger.exception')
+ def test_get_run_dict_if_defined_exception(self,
+ mock_logger_except):
+ with mock.patch('functest.ci.run_tests.'
+ 'ft_utils.get_dict_by_test',
+ side_effect=Exception):
+ testname = 'test_name'
+ self.assertEqual(run_tests.get_run_dict(testname),
+ None)
+ mock_logger_except.assert_called_once_with("Cannot get {}'s config"
+ " options"
+ .format(testname))
+
+ def test_run_tests_import_test_class_exception(self):
+ mock_test = mock.Mock()
+ args = {'get_name': 'test_name',
+ 'needs_clean': False}
+ mock_test.configure_mock(**args)
+ with mock.patch('functest.ci.run_tests.print_separator'),\
+ mock.patch('functest.ci.run_tests.source_rc_file'), \
+ mock.patch('functest.ci.run_tests.get_run_dict',
+ return_value=None), \
+ self.assertRaises(Exception) as context:
+ run_tests.run_test(mock_test, 'tier_name')
+ msg = "Cannot import the class for the test case."
+ self.assertTrue(msg in context)
+
+ @mock.patch('functest.ci.run_tests.logger.info')
+ def test_run_tier_default(self, mock_logger_info):
+ with mock.patch('functest.ci.run_tests.print_separator'), \
+ mock.patch('functest.ci.run_tests.run_test') as mock_method:
+ run_tests.run_tier(self.tier)
+ mock_method.assert_any_call('test1', 'test_tier')
+ mock_method.assert_any_call('test2', 'test_tier')
+ self.assertTrue(mock_logger_info.called)
+
+ @mock.patch('functest.ci.run_tests.logger.info')
+ def test_run_tier_missing_test(self, mock_logger_info):
+ with mock.patch('functest.ci.run_tests.print_separator'):
+ self.tier.get_tests.return_value = None
+ self.assertEqual(run_tests.run_tier(self.tier), 0)
+ self.assertTrue(mock_logger_info.called)
+
+ @mock.patch('functest.ci.run_tests.logger.info')
+ def test_run_all_default(self, mock_logger_info):
+ with mock.patch('functest.ci.run_tests.run_tier') as mock_method, \
+ mock.patch('functest.ci.run_tests.generate_report.init'), \
+ mock.patch('functest.ci.run_tests.generate_report.main'):
+ CONST.CI_LOOP = 'test_ci_loop'
+ run_tests.run_all(self.tiers)
+ mock_method.assert_any_call(self.tier)
+ self.assertTrue(mock_logger_info.called)
+
+ @mock.patch('functest.ci.run_tests.logger.info')
+ def test_run_all__missing_tier(self, mock_logger_info):
+ with mock.patch('functest.ci.run_tests.generate_report.init'), \
+ mock.patch('functest.ci.run_tests.generate_report.main'):
+ CONST.CI_LOOP = 'loop_re_not_available'
+ run_tests.run_all(self.tiers)
+ self.assertTrue(mock_logger_info.called)
+
+ def test_main_failed(self):
+ kwargs = {'test': 'test_name', 'noclean': True, 'report': True}
+ mock_obj = mock.Mock()
+ args = {'get_tier.return_value': False,
+ 'get_test.return_value': False}
+ mock_obj.configure_mock(**args)
+
+ with mock.patch('functest.ci.run_tests.tb.TierBuilder'), \
+ mock.patch('functest.ci.run_tests.source_rc_file',
+ side_effect=Exception):
+ self.assertEqual(run_tests.main(**kwargs),
+ run_tests.Result.EX_ERROR)
+
+ with mock.patch('functest.ci.run_tests.tb.TierBuilder',
+ return_value=mock_obj), \
+ mock.patch('functest.ci.run_tests.source_rc_file',
+ side_effect=Exception):
+ self.assertEqual(run_tests.main(**kwargs),
+ run_tests.Result.EX_ERROR)
+
+
+if __name__ == "__main__":
+ unittest.main(verbosity=2)
diff --git a/functest/tests/unit/ci/test_tier_builder.py b/functest/tests/unit/ci/test_tier_builder.py
new file mode 100644
index 000000000..48c94a57d
--- /dev/null
+++ b/functest/tests/unit/ci/test_tier_builder.py
@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+
+import logging
+import unittest
+
+import mock
+
+from functest.ci import tier_builder
+
+
+class TierBuilderTesting(unittest.TestCase):
+
+ logging.disable(logging.CRITICAL)
+
+ def setUp(self):
+ self.dependency = {'installer': 'test_installer',
+ 'scenario': 'test_scenario'}
+
+ self.testcase = {'dependencies': self.dependency,
+ 'name': 'test_name',
+ 'criteria': 'test_criteria',
+ 'blocking': 'test_blocking',
+ 'clean_flag': 'test_clean_flag',
+ 'description': 'test_desc'}
+
+ self.dic_tier = {'name': 'test_tier',
+ 'order': 'test_order',
+ 'ci_loop': 'test_ci_loop',
+ 'description': 'test_desc',
+ 'testcases': [self.testcase]}
+
+ self.mock_yaml = mock.Mock()
+ attrs = {'get.return_value': [self.dic_tier]}
+ self.mock_yaml.configure_mock(**attrs)
+
+ with mock.patch('functest.ci.tier_builder.yaml.safe_load',
+ return_value=self.mock_yaml), \
+ mock.patch('__builtin__.open', mock.mock_open()):
+ self.tierbuilder = tier_builder.TierBuilder('test_installer',
+ 'test_scenario',
+ 'testcases_file')
+ self.tier_obj = self.tierbuilder.tier_objects[0]
+
+ def test_get_tiers(self):
+ self.assertEqual(self.tierbuilder.get_tiers(),
+ [self.tier_obj])
+
+ def test_get_tier_names(self):
+ self.assertEqual(self.tierbuilder.get_tier_names(),
+ ['test_tier'])
+
+ def test_get_tier_present_tier(self):
+ self.assertEqual(self.tierbuilder.get_tier('test_tier'),
+ self.tier_obj)
+
+ def test_get_tier_missing_tier(self):
+ self.assertEqual(self.tierbuilder.get_tier('test_tier2'),
+ None)
+
+ def test_get_test_present_test(self):
+ self.assertEqual(self.tierbuilder.get_test('test_name'),
+ self.tier_obj.get_test('test_name'))
+
+ def test_get_test_missing_test(self):
+ self.assertEqual(self.tierbuilder.get_test('test_name2'),
+ None)
+
+ def test_get_tests_present_tier(self):
+ self.assertEqual(self.tierbuilder.get_tests('test_tier'),
+ self.tier_obj.tests_array)
+
+ def test_get_tests_missing_tier(self):
+ self.assertEqual(self.tierbuilder.get_tests('test_tier2'),
+ None)
+
+
+if __name__ == "__main__":
+ unittest.main(verbosity=2)
diff --git a/functest/tests/unit/ci/test_tier_handler.py b/functest/tests/unit/ci/test_tier_handler.py
new file mode 100644
index 000000000..01d99d7e7
--- /dev/null
+++ b/functest/tests/unit/ci/test_tier_handler.py
@@ -0,0 +1,128 @@
+#!/usr/bin/env python
+
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+
+import logging
+import unittest
+
+import mock
+
+from functest.ci import tier_handler
+
+
+class TierHandlerTesting(unittest.TestCase):
+
+ logging.disable(logging.CRITICAL)
+
+ def setUp(self):
+ self.test = mock.Mock()
+ attrs = {'get_name.return_value': 'test_name'}
+ self.test.configure_mock(**attrs)
+
+ self.mock_depend = mock.Mock()
+ attrs = {'get_scenario.return_value': 'test_scenario',
+ 'get_installer.return_value': 'test_installer'}
+ self.mock_depend.configure_mock(**attrs)
+
+ self.tier = tier_handler.Tier('test_tier',
+ 'test_order',
+ 'test_ci_loop',
+ description='test_desc')
+ self.testcase = tier_handler.TestCase('test_name',
+ self.mock_depend,
+ 'test_criteria',
+ 'test_blocking',
+ 'test_clean_flag',
+ description='test_desc')
+
+ self.dependency = tier_handler.Dependency('test_installer',
+ 'test_scenario')
+
+ def test_add_test(self):
+ self.tier.add_test(self.test)
+ self.assertEqual(self.tier.tests_array,
+ [self.test])
+
+ def test_get_tests(self):
+ self.tier.tests_array = [self.test]
+ self.assertEqual(self.tier.get_tests(),
+ [self.test])
+
+ def test_get_test_names(self):
+ self.tier.tests_array = [self.test]
+ self.assertEqual(self.tier.get_test_names(),
+ ['test_name'])
+
+ def test_get_test(self):
+ self.tier.tests_array = [self.test]
+ with mock.patch.object(self.tier, 'is_test',
+ return_value=True):
+ self.assertEqual(self.tier.get_test('test_name'),
+ self.test)
+
+ def test_get_test_missing_test(self):
+ self.tier.tests_array = [self.test]
+ with mock.patch.object(self.tier, 'is_test',
+ return_value=False):
+ self.assertEqual(self.tier.get_test('test_name'),
+ None)
+
+ def test_get_name(self):
+ self.assertEqual(self.tier.get_name(),
+ 'test_tier')
+
+ def test_get_order(self):
+ self.assertEqual(self.tier.get_order(),
+ 'test_order')
+
+ def test_get_ci_loop(self):
+ self.assertEqual(self.tier.get_ci_loop(),
+ 'test_ci_loop')
+
+ def test_testcase_is_none_present_item(self):
+ self.assertEqual(tier_handler.TestCase.is_none("item"),
+ False)
+
+ def test_testcase_is_none_missing_item(self):
+ self.assertEqual(tier_handler.TestCase.is_none(None),
+ True)
+
+ def test_testcase_is_compatible(self):
+ self.assertEqual(self.testcase.is_compatible('test_installer',
+ 'test_scenario'),
+ True)
+
+ def test_testcase_is_compatible_missing_installer_scenario(self):
+ self.assertEqual(self.testcase.is_compatible('missing_installer',
+ 'test_scenario'),
+ False)
+ self.assertEqual(self.testcase.is_compatible('test_installer',
+ 'missing_scenario'),
+ False)
+
+ def test_testcase_get_name(self):
+ self.assertEqual(self.tier.get_name(),
+ 'test_tier')
+
+ def test_testcase_get_criteria(self):
+ self.assertEqual(self.tier.get_order(),
+ 'test_order')
+
+ def test_testcase_is_blocking(self):
+ self.assertEqual(self.tier.get_ci_loop(),
+ 'test_ci_loop')
+
+ def test_dependency_get_installer(self):
+ self.assertEqual(self.dependency.get_installer(),
+ 'test_installer')
+
+ def test_dependency_get_scenario(self):
+ self.assertEqual(self.dependency.get_scenario(),
+ 'test_scenario')
+
+
+if __name__ == "__main__":
+ unittest.main(verbosity=2)
diff --git a/functest/tests/unit/opnfv_tests/openstack/refstack_client/test_refstack_client.py b/functest/tests/unit/opnfv_tests/openstack/refstack_client/test_refstack_client.py
index 4eb5a2501..4e83f6bf3 100644
--- a/functest/tests/unit/opnfv_tests/openstack/refstack_client/test_refstack_client.py
+++ b/functest/tests/unit/opnfv_tests/openstack/refstack_client/test_refstack_client.py
@@ -38,17 +38,6 @@ class OSRefstackClientTesting(unittest.TestCase):
self.refstackclient.source_venv()
m.assert_any_call(cmd)
- def test_run_defcore_default(self):
- with mock.patch('functest.opnfv_tests.openstack.refstack_client.'
- 'refstack_client.ft_utils.execute_command') as m:
- cmd = ("cd {0};"
- "./refstack-client test -c {1} -v --test-list {2};"
- "cd -;".format(CONST.dir_refstack_client,
- self._config,
- self._testlist))
- self.refstackclient.run_defcore_default()
- m.assert_any_call(cmd)
-
def test_run_defcore(self):
config = 'tempest.conf'
testlist = 'testlist'
diff --git a/functest/tests/unit/utils/test_functest_utils.py b/functest/tests/unit/utils/test_functest_utils.py
index bb8360119..8bfdb5e49 100644
--- a/functest/tests/unit/utils/test_functest_utils.py
+++ b/functest/tests/unit/utils/test_functest_utils.py
@@ -56,6 +56,7 @@ class FunctestUtilsTesting(unittest.TestCase):
self.testcase_dict = {'name': 'testname', 'criteria': self.criteria}
self.parameter = 'general.openstack.image_name'
self.config_yaml = 'test_config_yaml-'
+ self.db_url_env = 'http://foo/testdb'
self.file_yaml = {'general': {'openstack': {'image_name':
'test_image_name'}}}
@@ -196,8 +197,17 @@ class FunctestUtilsTesting(unittest.TestCase):
self.assertEqual(functest_utils.get_build_tag(),
self.build_tag)
+ def test_get_db_url_env_var(self):
+ with mock.patch.dict(os.environ,
+ {'TEST_DB_URL': self.db_url_env,
+ 'CONFIG_FUNCTEST_YAML':
+ "./functest/ci/config_functest.yaml"},
+ clear=True):
+ self.assertEqual(functest_utils.get_db_url(),
+ self.db_url_env)
+
@mock.patch('functest.utils.functest_utils.get_functest_config')
- def test_get_db_url(self, mock_get_functest_config):
+ def test_get_db_url_default(self, mock_get_functest_config):
mock_get_functest_config.return_value = self.db_url
self.assertEqual(functest_utils.get_db_url(), self.db_url)
mock_get_functest_config.assert_called_once_with('results.test_db_url')
diff --git a/functest/utils/functest_utils.py b/functest/utils/functest_utils.py
index dbed811a7..e5e755d7f 100644
--- a/functest/utils/functest_utils.py
+++ b/functest/utils/functest_utils.py
@@ -151,7 +151,15 @@ def get_db_url():
"""
Returns DB URL
"""
- return get_functest_config('results.test_db_url')
+ # TODO use CONST mechanism
+ try:
+ # if TEST_DB_URL declared in env variable, use it!
+ db_url = os.environ['TEST_DB_URL']
+ except KeyError:
+ logger.info("DB URL not declared as env variable,"
+ "use local configuration")
+ db_url = get_functest_config('results.test_db_url')
+ return db_url
def logger_test_results(project, case_name, status, details):