diff options
Diffstat (limited to 'functest/tests')
| -rw-r--r-- | functest/tests/unit/ci/test_prepare_env.py | 111 | ||||
| -rw-r--r-- | functest/tests/unit/ci/test_run_tests.py | 84 | ||||
| -rw-r--r-- | functest/tests/unit/ci/test_tier_handler.py | 9 | ||||
| -rw-r--r-- | functest/tests/unit/core/test_testcase.py (renamed from functest/tests/unit/core/test_testcase_base.py) | 7 | ||||
| -rw-r--r-- | functest/tests/unit/odl/test_odl.py | 371 | ||||
| -rw-r--r-- | functest/tests/unit/opnfv_tests/openstack/tempest/test_conf_utils.py | 222 | ||||
| -rw-r--r-- | functest/tests/unit/opnfv_tests/openstack/tempest/test_tempest.py | 51 | ||||
| -rw-r--r-- | functest/tests/unit/opnfv_tests/vnf/ims/test_clearwater.py | 34 | ||||
| -rw-r--r-- | functest/tests/unit/opnfv_tests/vnf/ims/test_cloudify_ims.py | 118 | ||||
| -rw-r--r-- | functest/tests/unit/opnfv_tests/vnf/ims/test_ims_base.by | 58 | ||||
| -rw-r--r-- | functest/tests/unit/opnfv_tests/vnf/ims/test_orchestrator_cloudify.py | 55 | ||||
| -rw-r--r-- | functest/tests/unit/utils/test_functest_logger.py | 48 | ||||
| -rw-r--r-- | functest/tests/unit/utils/test_openstack_tacker.py | 92 | ||||
| -rw-r--r-- | functest/tests/unit/utils/test_openstack_utils.py | 55 |
14 files changed, 1058 insertions, 257 deletions
diff --git a/functest/tests/unit/ci/test_prepare_env.py b/functest/tests/unit/ci/test_prepare_env.py index 540501ff..714dd13c 100644 --- a/functest/tests/unit/ci/test_prepare_env.py +++ b/functest/tests/unit/ci/test_prepare_env.py @@ -20,6 +20,9 @@ class PrepareEnvTesting(unittest.TestCase): logging.disable(logging.CRITICAL) + def setUp(self): + self.prepare_envparser = prepare_env.PrepareEnvParser() + @mock.patch('functest.ci.prepare_env.logger.info') def test_print_separator(self, mock_logger_info): str = "==============================================" @@ -81,7 +84,7 @@ class PrepareEnvTesting(unittest.TestCase): @mock.patch('functest.ci.prepare_env.logger.warning') def test_check_env_variables_with_scenario(self, mock_logger_warn, mock_logger_info): - CONST.DEPLOY_SCENARIO = mock.Mock() + CONST.DEPLOY_SCENARIO = 'test_scenario' prepare_env.check_env_variables() mock_logger_info.assert_any_call("Checking environment variables" "...") @@ -134,6 +137,47 @@ class PrepareEnvTesting(unittest.TestCase): mock_logger_info.assert_any_call(test_utils. SubstrMatch(" IS_CI_RUN=")) + def test_get_deployment_handler_missing_const_vars(self): + with mock.patch('functest.ci.prepare_env.' + 'factory.Factory.get_handler') as m: + CONST.INSTALLER_IP = None + prepare_env.get_deployment_handler() + self.assertFalse(m.called) + + CONST.INSTALLER_TYPE = None + prepare_env.get_deployment_handler() + self.assertFalse(m.called) + + @mock.patch('functest.ci.prepare_env.logger.debug') + def test_get_deployment_handler_missing_print_deploy_info(self, + mock_debug): + with mock.patch('functest.ci.prepare_env.' + 'factory.Factory.get_handler') as m, \ + mock.patch('functest.ci.prepare_env.' + 'ft_utils.get_parameter_from_yaml', + side_effect=ValueError): + CONST.INSTALLER_IP = 'test_ip' + CONST.INSTALLER_TYPE = 'test_inst_type' + opnfv_constants.INSTALLERS = ['test_inst_type'] + prepare_env.get_deployment_handler() + msg = ('Printing deployment info is not supported for ' + 'test_inst_type') + mock_debug.assert_any_call(msg) + self.assertFalse(m.called) + + @mock.patch('functest.ci.prepare_env.logger.debug') + def test_get_deployment_handler_exception(self, mock_debug): + with mock.patch('functest.ci.prepare_env.' + 'factory.Factory.get_handler', + side_effect=Exception), \ + mock.patch('functest.ci.prepare_env.' + 'ft_utils.get_parameter_from_yaml'): + CONST.INSTALLER_IP = 'test_ip' + CONST.INSTALLER_TYPE = 'test_inst_type' + opnfv_constants.INSTALLERS = ['test_inst_type'] + prepare_env.get_deployment_handler() + self.assertTrue(mock_debug.called) + @mock.patch('functest.ci.prepare_env.logger.info') @mock.patch('functest.ci.prepare_env.logger.debug') def test_create_directories_missing_dir(self, mock_logger_debug, @@ -228,6 +272,36 @@ class PrepareEnvTesting(unittest.TestCase): prepare_env.source_rc_file() + @mock.patch('functest.ci.prepare_env.logger.debug') + def test_patch_file(self, mock_logger_debug): + with mock.patch("__builtin__.open", mock.mock_open()), \ + mock.patch('functest.ci.prepare_env.yaml.safe_load', + return_value={'test_scenario': {'tkey': 'tvalue'}}), \ + mock.patch('functest.ci.prepare_env.ft_utils.get_functest_yaml', + return_value={'tkey1': 'tvalue1'}), \ + mock.patch('functest.ci.prepare_env.os.remove') as m, \ + mock.patch('functest.ci.prepare_env.yaml.dump'): + CONST.DEPLOY_SCENARIO = 'test_scenario' + prepare_env.patch_file('test_file') + self.assertTrue(m.called) + + @mock.patch('functest.ci.prepare_env.logger.info') + def test_verify_deployment_error(self, mock_logger_error): + mock_popen = mock.Mock() + attrs = {'poll.return_value': None, + 'stdout.readline.return_value': 'ERROR'} + mock_popen.configure_mock(**attrs) + + with mock.patch('functest.ci.prepare_env.print_separator') as m, \ + mock.patch('functest.ci.prepare_env.subprocess.Popen', + return_value=mock_popen), \ + self.assertRaises(Exception) as context: + prepare_env.verify_deployment() + self.assertTrue(m.called) + msg = "Problem while running 'check_os.sh'." + mock_logger_error.assert_called_once_with('ERROR') + self.assertTrue(msg in context) + def _get_rally_creds(self): return {"type": "ExistingCloud", "admin": {"username": 'test_user_name', @@ -271,6 +345,33 @@ class PrepareEnvTesting(unittest.TestCase): "Rally plugins.") mock_exec.assert_any_call(cmd, error_msg=error_msg) + @mock.patch('functest.ci.prepare_env.logger.debug') + def test_install_tempest(self, mock_logger_debug): + mock_popen = mock.Mock() + attrs = {'poll.return_value': None, + 'stdout.readline.return_value': '0'} + mock_popen.configure_mock(**attrs) + + CONST.tempest_deployment_name = 'test_dep_name' + with mock.patch('functest.ci.prepare_env.' + 'ft_utils.execute_command_raise', + side_effect=Exception), \ + mock.patch('functest.ci.prepare_env.subprocess.Popen', + return_value=mock_popen), \ + self.assertRaises(Exception): + prepare_env.install_tempest() + mock_logger_debug.assert_any_call("Tempest test_dep_name" + " does not exist") + + def test_create_flavor(self): + with mock.patch('functest.ci.prepare_env.' + 'os_utils.get_or_create_flavor', + return_value=('test_', None)), \ + self.assertRaises(Exception) as context: + prepare_env.create_flavor() + msg = 'Failed to create flavor' + self.assertTrue(msg in context) + @mock.patch('functest.ci.prepare_env.sys.exit') @mock.patch('functest.ci.prepare_env.logger.error') def test_check_environment_missing_file(self, mock_logger_error, @@ -299,6 +400,7 @@ class PrepareEnvTesting(unittest.TestCase): mock_logger_info.assert_any_call("Functest environment" " is installed.") + @mock.patch('functest.ci.prepare_env.print_deployment_info') @mock.patch('functest.ci.prepare_env.check_environment') @mock.patch('functest.ci.prepare_env.create_flavor') @mock.patch('functest.ci.prepare_env.install_tempest') @@ -307,19 +409,21 @@ class PrepareEnvTesting(unittest.TestCase): @mock.patch('functest.ci.prepare_env.patch_config_file') @mock.patch('functest.ci.prepare_env.source_rc_file') @mock.patch('functest.ci.prepare_env.create_directories') + @mock.patch('functest.ci.prepare_env.get_deployment_handler') @mock.patch('functest.ci.prepare_env.check_env_variables') @mock.patch('functest.ci.prepare_env.logger.info') - def test_main_start(self, mock_logger_info, mock_env_var, + def test_main_start(self, mock_logger_info, mock_env_var, mock_dep_handler, mock_create_dir, mock_source_rc, mock_patch_config, mock_verify_depl, mock_install_rally, mock_install_temp, mock_create_flavor, - mock_check_env): + mock_check_env, mock_print_info): with mock.patch("__builtin__.open", mock.mock_open()) as m: args = {'action': 'start'} self.assertEqual(prepare_env.main(**args), 0) mock_logger_info.assert_any_call("######### Preparing Functest " "environment #########\n") self.assertTrue(mock_env_var.called) + self.assertTrue(mock_dep_handler.called) self.assertTrue(mock_create_dir.called) self.assertTrue(mock_source_rc.called) self.assertTrue(mock_patch_config.called) @@ -329,6 +433,7 @@ class PrepareEnvTesting(unittest.TestCase): self.assertTrue(mock_create_flavor.called) m.assert_called_once_with(CONST.env_active, "w") self.assertTrue(mock_check_env.called) + self.assertTrue(mock_print_info.called) @mock.patch('functest.ci.prepare_env.check_environment') def test_main_check(self, mock_check_env): diff --git a/functest/tests/unit/ci/test_run_tests.py b/functest/tests/unit/ci/test_run_tests.py index 02140610..7d02b1af 100644 --- a/functest/tests/unit/ci/test_run_tests.py +++ b/functest/tests/unit/ci/test_run_tests.py @@ -37,6 +37,9 @@ class RunTestsTesting(unittest.TestCase): attrs = {'get_tiers.return_value': [self.tier]} self.tiers.configure_mock(**attrs) + self.run_tests_parser = run_tests.RunTestsParser() + self.global_variables = run_tests.GlobalVariables() + @mock.patch('functest.ci.run_tests.logger.info') def test_print_separator(self, mock_logger_info): run_tests.print_separator(self.sep) @@ -121,8 +124,8 @@ class RunTestsTesting(unittest.TestCase): def test_run_tests_import_test_class_exception(self): mock_test = mock.Mock() - args = {'get_name': 'test_name', - 'needs_clean': False} + args = {'get_name.return_value': 'test_name', + 'needs_clean.return_value': False} mock_test.configure_mock(**args) with mock.patch('functest.ci.run_tests.print_separator'),\ mock.patch('functest.ci.run_tests.source_rc_file'), \ @@ -133,6 +136,28 @@ class RunTestsTesting(unittest.TestCase): msg = "Cannot import the class for the test case." self.assertTrue(msg in context) + def test_run_tests_default(self): + mock_test = mock.Mock() + args = {'get_name.return_value': 'test_name', + 'needs_clean.return_value': True} + mock_test.configure_mock(**args) + test_run_dict = {'module': 'test_module', + 'class': mock.Mock, + 'args': 'test_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.generate_os_snapshot'), \ + mock.patch('functest.ci.run_tests.cleanup'), \ + mock.patch('functest.ci.run_tests.update_test_info'), \ + mock.patch('functest.ci.run_tests.get_run_dict', + return_value=test_run_dict), \ + mock.patch('functest.ci.run_tests.generate_report.main'), \ + self.assertRaises(run_tests.BlockingTestFailed) as context: + run_tests.GlobalVariables.CLEAN_FLAG = True + run_tests.run_test(mock_test, 'tier_name') + msg = 'The test case test_name failed and is blocking' + 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'), \ @@ -187,6 +212,61 @@ class RunTestsTesting(unittest.TestCase): self.assertEqual(run_tests.main(**kwargs), run_tests.Result.EX_ERROR) + def test_main_default(self): + kwargs = {'test': 'test_name', 'noclean': True, 'report': True} + mock_obj = mock.Mock() + args = {'get_tier.return_value': True, + 'get_test.return_value': False} + mock_obj.configure_mock(**args) + with mock.patch('functest.ci.run_tests.tb.TierBuilder', + return_value=mock_obj), \ + mock.patch('functest.ci.run_tests.source_rc_file'), \ + mock.patch('functest.ci.run_tests.generate_report.init'), \ + mock.patch('functest.ci.run_tests.run_tier') as m: + self.assertEqual(run_tests.main(**kwargs), + run_tests.Result.EX_OK) + self.assertTrue(m.called) + + mock_obj = mock.Mock() + args = {'get_tier.return_value': False, + 'get_test.return_value': True} + mock_obj.configure_mock(**args) + with mock.patch('functest.ci.run_tests.tb.TierBuilder', + return_value=mock_obj), \ + mock.patch('functest.ci.run_tests.source_rc_file'), \ + mock.patch('functest.ci.run_tests.generate_report.init'), \ + mock.patch('functest.ci.run_tests.run_test') as m: + self.assertEqual(run_tests.main(**kwargs), + run_tests.Result.EX_OK) + self.assertTrue(m.called) + + kwargs = {'test': 'all', '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', + return_value=mock_obj), \ + mock.patch('functest.ci.run_tests.source_rc_file'), \ + mock.patch('functest.ci.run_tests.generate_report.init'), \ + mock.patch('functest.ci.run_tests.run_all') as m: + self.assertEqual(run_tests.main(**kwargs), + run_tests.Result.EX_OK) + self.assertTrue(m.called) + + kwargs = {'test': 'any', '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', + return_value=mock_obj), \ + mock.patch('functest.ci.run_tests.source_rc_file'), \ + mock.patch('functest.ci.run_tests.generate_report.init'), \ + mock.patch('functest.ci.run_tests.logger.debug') as m: + self.assertEqual(run_tests.main(**kwargs), + run_tests.Result.EX_ERROR) + self.assertTrue(m.called) 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 index 01d99d7e..21df4098 100644 --- a/functest/tests/unit/ci/test_tier_handler.py +++ b/functest/tests/unit/ci/test_tier_handler.py @@ -41,6 +41,15 @@ class TierHandlerTesting(unittest.TestCase): self.dependency = tier_handler.Dependency('test_installer', 'test_scenario') + self.testcase.str = self.testcase.__str__() + self.dependency.str = self.dependency.__str__() + self.tier.str = self.tier.__str__() + + def test_split_text(self): + test_str = 'this is for testing' + self.assertEqual(tier_handler.split_text(test_str, 10), + ['this is ', 'for ', 'testing ']) + def test_add_test(self): self.tier.add_test(self.test) self.assertEqual(self.tier.tests_array, diff --git a/functest/tests/unit/core/test_testcase_base.py b/functest/tests/unit/core/test_testcase.py index 9ee1609f..32104194 100644 --- a/functest/tests/unit/core/test_testcase_base.py +++ b/functest/tests/unit/core/test_testcase.py @@ -7,6 +7,8 @@ # which accompanies this distribution, and is available at # http://www.apache.org/licenses/LICENSE-2.0 +"""Define the classe required to fully cover testcase.""" + import logging import unittest @@ -14,9 +16,14 @@ import mock from functest.core import testcase +__author__ = "Cedric Ollivier <cedric.ollivier@orange.com>" + class TestCaseTesting(unittest.TestCase): + """The class testing TestCase.""" + # pylint: disable=missing-docstring + logging.disable(logging.CRITICAL) def setUp(self): diff --git a/functest/tests/unit/odl/test_odl.py b/functest/tests/unit/odl/test_odl.py index 6967eb1a..e08deb27 100644 --- a/functest/tests/unit/odl/test_odl.py +++ b/functest/tests/unit/odl/test_odl.py @@ -7,14 +7,16 @@ # which accompanies this distribution, and is available at # http://www.apache.org/licenses/LICENSE-2.0 +"""Define the classes required to fully cover odl.""" + import errno import logging -import mock import os import StringIO import unittest from keystoneauth1.exceptions import auth_plugins +import mock from robot.errors import DataError, RobotError from robot.result import testcase as result_testcase from robot.utils.robottime import timestamp_to_secs @@ -22,9 +24,50 @@ from robot.utils.robottime import timestamp_to_secs from functest.core import testcase from functest.opnfv_tests.sdn.odl import odl +__author__ = "Cedric Ollivier <cedric.ollivier@orange.com>" + + +class ODLVisitorTesting(unittest.TestCase): + + """The class testing ODLResultVisitor.""" + # pylint: disable=missing-docstring + + logging.disable(logging.CRITICAL) + + def setUp(self): + self.visitor = odl.ODLResultVisitor() + + def test_empty(self): + self.assertFalse(self.visitor.get_data()) + + def test_ok(self): + data = {'name': 'foo', + 'parent': 'bar', + 'status': 'PASS', + 'starttime': "20161216 16:00:00.000", + 'endtime': "20161216 16:00:01.000", + 'elapsedtime': 1000, + 'text': 'Hello, World!', + 'critical': True} + test = result_testcase.TestCase(name=data['name'], + status=data['status'], + message=data['text'], + starttime=data['starttime'], + endtime=data['endtime']) + test.parent = mock.Mock() + config = {'name': data['parent'], + 'criticality.test_is_critical.return_value': data[ + 'critical']} + test.parent.configure_mock(**config) + self.visitor.visit_test(test) + self.assertEqual(self.visitor.get_data(), [data]) + class ODLTesting(unittest.TestCase): + """The super class which testing classes could inherit.""" + # pylint: disable=missing-docstring + logging.disable(logging.CRITICAL) _keystone_ip = "127.0.0.1" @@ -60,39 +103,19 @@ class ODLTesting(unittest.TestCase): 'odlrestconfport': self._odl_restconfport, 'pushtodb': False} - def test_empty_visitor(self): - visitor = odl.ODLResultVisitor() - self.assertFalse(visitor.get_data()) - def test_visitor(self): - visitor = odl.ODLResultVisitor() - data = {'name': 'foo', - 'parent': 'bar', - 'status': 'PASS', - 'starttime': "20161216 16:00:00.000", - 'endtime': "20161216 16:00:01.000", - 'elapsedtime': 1000, - 'text': 'Hello, World!', - 'critical': True} - test = result_testcase.TestCase(name=data['name'], - status=data['status'], - message=data['text'], - starttime=data['starttime'], - endtime=data['endtime']) - test.parent = mock.Mock() - config = {'name': data['parent'], - 'criticality.test_is_critical.return_value': data[ - 'critical']} - test.parent.configure_mock(**config) - visitor.visit_test(test) - self.assertEqual(visitor.get_data(), [data]) +class ODLParseResultTesting(ODLTesting): + + """The class testing ODLTests.parse_results().""" + # pylint: disable=missing-docstring @mock.patch('robot.api.ExecutionResult', side_effect=DataError) - def test_parse_results_raises_exceptions(self, *args): + def test_raises_exc(self, mock_method): with self.assertRaises(DataError): self.test.parse_results() + mock_method.assert_called_once_with() - def test_parse_results(self, *args): + def test_ok(self): config = {'name': 'dummy', 'starttime': '20161216 16:00:00.000', 'endtime': '20161216 16:00:01.000', 'status': 'PASS'} suite = mock.Mock() @@ -108,16 +131,28 @@ class ODLTesting(unittest.TestCase): self.assertEqual(self.test.details, {'description': config['name'], 'tests': []}) + +class ODLRobotTesting(ODLTesting): + + """The class testing ODLTests.set_robotframework_vars().""" + # pylint: disable=missing-docstring + @mock.patch('fileinput.input', side_effect=Exception()) - def test_set_robotframework_vars_failed(self, *args): + def test_set_vars_ko(self, mock_method): self.assertFalse(self.test.set_robotframework_vars()) + mock_method.assert_called_once_with( + os.path.join(odl.ODLTests.odl_test_repo, + 'csit/variables/Variables.py'), inplace=True) @mock.patch('fileinput.input', return_value=[]) - def test_set_robotframework_vars_empty(self, args): + def test_set_vars_empty(self, mock_method): self.assertTrue(self.test.set_robotframework_vars()) + mock_method.assert_called_once_with( + os.path.join(odl.ODLTests.odl_test_repo, + 'csit/variables/Variables.py'), inplace=True) @mock.patch('sys.stdout', new_callable=StringIO.StringIO) - def _test_set_robotframework_vars(self, msg1, msg2, *args): + def _test_set_vars(self, msg1, msg2, *args): line = mock.MagicMock() line.__iter__.return_value = [msg1] with mock.patch('fileinput.input', return_value=line) as mock_method: @@ -127,15 +162,15 @@ class ODLTesting(unittest.TestCase): 'csit/variables/Variables.py'), inplace=True) self.assertEqual(args[0].getvalue(), "{}\n".format(msg2)) - def test_set_robotframework_vars_auth_default(self): - self._test_set_robotframework_vars("AUTH = []", - "AUTH = [u'admin', u'admin']") + def test_set_vars_auth_default(self): + self._test_set_vars("AUTH = []", + "AUTH = [u'admin', u'admin']") - def test_set_robotframework_vars_auth1(self): - self._test_set_robotframework_vars("AUTH1 = []", "AUTH1 = []") + def test_set_vars_auth1(self): + self._test_set_vars("AUTH1 = []", "AUTH1 = []") @mock.patch('sys.stdout', new_callable=StringIO.StringIO) - def test_set_robotframework_vars_auth_foo(self, *args): + def test_set_vars_auth_foo(self, *args): line = mock.MagicMock() line.__iter__.return_value = ["AUTH = []"] with mock.patch('fileinput.input', return_value=line) as mock_method: @@ -146,15 +181,11 @@ class ODLTesting(unittest.TestCase): self.assertEqual(args[0].getvalue(), "AUTH = [u'{}', u'{}']\n".format('foo', 'bar')) - @classmethod - def _fake_url_for(cls, service_type='identity', **kwargs): - if service_type == 'identity': - return "http://{}:5000/v2.0".format( - ODLTesting._keystone_ip) - elif service_type == 'network': - return "http://{}:9696".format(ODLTesting._neutron_ip) - else: - return None + +class ODLMainTesting(ODLTesting): + + """The class testing ODLTests.main().""" + # pylint: disable=missing-docstring def _get_main_kwargs(self, key=None): kwargs = {'odlusername': self._odl_username, @@ -199,50 +230,50 @@ class ODLTesting(unittest.TestCase): args[2].assert_called_with( os.path.join(odl.ODLTests.res_dir, 'stdout.txt')) - def _test_main_missing_keyword(self, key): + def _test_no_keyword(self, key): kwargs = self._get_main_kwargs(key) self.assertEqual(self.test.main(**kwargs), testcase.TestCase.EX_RUN_ERROR) - def test_main_missing_odlusername(self): - self._test_main_missing_keyword('odlusername') + def test_no_odlusername(self): + self._test_no_keyword('odlusername') - def test_main_missing_odlpassword(self): - self._test_main_missing_keyword('odlpassword') + def test_no_odlpassword(self): + self._test_no_keyword('odlpassword') - def test_main_missing_neutronip(self): - self._test_main_missing_keyword('neutronip') + def test_no_neutronip(self): + self._test_no_keyword('neutronip') - def test_main_missing_osauthurl(self): - self._test_main_missing_keyword('osauthurl') + def test_no_osauthurl(self): + self._test_no_keyword('osauthurl') - def test_main_missing_osusername(self): - self._test_main_missing_keyword('osusername') + def test_no_osusername(self): + self._test_no_keyword('osusername') - def test_main_missing_ostenantname(self): - self._test_main_missing_keyword('ostenantname') + def test_no_ostenantname(self): + self._test_no_keyword('ostenantname') - def test_main_missing_ospassword(self): - self._test_main_missing_keyword('ospassword') + def test_no_ospassword(self): + self._test_no_keyword('ospassword') - def test_main_missing_odlip(self): - self._test_main_missing_keyword('odlip') + def test_no_odlip(self): + self._test_no_keyword('odlip') - def test_main_missing_odlwebport(self): - self._test_main_missing_keyword('odlwebport') + def test_no_odlwebport(self): + self._test_no_keyword('odlwebport') - def test_main_missing_odlrestconfport(self): - self._test_main_missing_keyword('odlrestconfport') + def test_no_odlrestconfport(self): + self._test_no_keyword('odlrestconfport') - def test_main_set_robotframework_vars_failed(self): + def test_set_vars_ko(self): with mock.patch.object(self.test, 'set_robotframework_vars', - return_value=False): + return_value=False) as mock_object: self._test_main(testcase.TestCase.EX_RUN_ERROR) - self.test.set_robotframework_vars.assert_called_once_with( + mock_object.assert_called_once_with( self._odl_username, self._odl_password) @mock.patch('os.makedirs', side_effect=Exception) - def test_main_makedirs_exception(self, mock_method): + def test_makedirs_exc(self, mock_method): with mock.patch.object(self.test, 'set_robotframework_vars', return_value=True), \ self.assertRaises(Exception): @@ -250,7 +281,7 @@ class ODLTesting(unittest.TestCase): mock_method) @mock.patch('os.makedirs', side_effect=OSError) - def test_main_makedirs_oserror(self, mock_method): + def test_makedirs_oserror(self, mock_method): with mock.patch.object(self.test, 'set_robotframework_vars', return_value=True): self._test_main(testcase.TestCase.EX_RUN_ERROR, @@ -258,7 +289,7 @@ class ODLTesting(unittest.TestCase): @mock.patch('robot.run', side_effect=RobotError) @mock.patch('os.makedirs') - def test_main_robot_run_failed(self, *args): + def test_run_ko(self, *args): with mock.patch.object(self.test, 'set_robotframework_vars', return_value=True), \ mock.patch.object(odl, 'open', mock.mock_open(), @@ -268,7 +299,7 @@ class ODLTesting(unittest.TestCase): @mock.patch('robot.run') @mock.patch('os.makedirs') - def test_main_parse_results_failed(self, *args): + def test_parse_results_ko(self, *args): with mock.patch.object(self.test, 'set_robotframework_vars', return_value=True), \ mock.patch.object(odl, 'open', mock.mock_open(), @@ -280,7 +311,7 @@ class ODLTesting(unittest.TestCase): @mock.patch('os.remove', side_effect=Exception) @mock.patch('robot.run') @mock.patch('os.makedirs') - def test_main_remove_exception(self, *args): + def test_remove_exc(self, *args): with mock.patch.object(self.test, 'set_robotframework_vars', return_value=True), \ mock.patch.object(self.test, 'parse_results'), \ @@ -290,7 +321,7 @@ class ODLTesting(unittest.TestCase): @mock.patch('os.remove') @mock.patch('robot.run') @mock.patch('os.makedirs') - def test_main(self, *args): + def test_ok(self, *args): with mock.patch.object(self.test, 'set_robotframework_vars', return_value=True), \ mock.patch.object(odl, 'open', mock.mock_open(), @@ -301,7 +332,7 @@ class ODLTesting(unittest.TestCase): @mock.patch('os.remove') @mock.patch('robot.run') @mock.patch('os.makedirs', side_effect=OSError(errno.EEXIST, '')) - def test_main_makedirs_oserror17(self, *args): + def test_makedirs_oserror17(self, *args): with mock.patch.object(self.test, 'set_robotframework_vars', return_value=True), \ mock.patch.object(odl, 'open', mock.mock_open(), @@ -312,7 +343,7 @@ class ODLTesting(unittest.TestCase): @mock.patch('os.remove') @mock.patch('robot.run', return_value=1) @mock.patch('os.makedirs') - def test_main_testcases_in_failure(self, *args): + def test_testcases_in_failure(self, *args): with mock.patch.object(self.test, 'set_robotframework_vars', return_value=True), \ mock.patch.object(odl, 'open', mock.mock_open(), @@ -323,7 +354,7 @@ class ODLTesting(unittest.TestCase): @mock.patch('os.remove', side_effect=OSError) @mock.patch('robot.run') @mock.patch('os.makedirs') - def test_main_remove_oserror(self, *args): + def test_remove_oserror(self, *args): with mock.patch.object(self.test, 'set_robotframework_vars', return_value=True), \ mock.patch.object(odl, 'open', mock.mock_open(), @@ -331,7 +362,23 @@ class ODLTesting(unittest.TestCase): mock.patch.object(self.test, 'parse_results'): self._test_main(testcase.TestCase.EX_OK, *args) - def _test_run_missing_env_var(self, var): + +class ODLRunTesting(ODLTesting): + + """The class testing ODLTests.run().""" + # pylint: disable=missing-docstring + + @classmethod + def _fake_url_for(cls, service_type='identity'): + if service_type == 'identity': + return "http://{}:5000/v2.0".format( + ODLTesting._keystone_ip) + elif service_type == 'network': + return "http://{}:9696".format(ODLTesting._neutron_ip) + else: + return None + + def _test_no_env_var(self, var): with mock.patch('functest.utils.openstack_utils.get_endpoint', side_effect=self._fake_url_for): del os.environ[var] @@ -339,8 +386,12 @@ class ODLTesting(unittest.TestCase): testcase.TestCase.EX_RUN_ERROR) def _test_run(self, status=testcase.TestCase.EX_OK, - exception=None, odlip="127.0.0.3", odlwebport="8080", - odlrestconfport="8181"): + exception=None, **kwargs): + odlip = kwargs['odlip'] if 'odlip' in kwargs else '127.0.0.3' + odlwebport = kwargs['odlwebport'] if 'odlwebport' in kwargs else '8080' + odlrestconfport = (kwargs['odlrestconfport'] + if 'odlrestconfport' in kwargs else '8181') + with mock.patch('functest.utils.openstack_utils.get_endpoint', side_effect=self._fake_url_for): if exception: @@ -358,11 +409,13 @@ class ODLTesting(unittest.TestCase): ospassword=self._os_password, ostenantname=self._os_tenantname, osusername=self._os_username) - def _test_run_defining_multiple_suites( - self, suites, - status=testcase.TestCase.EX_OK, - exception=None, odlip="127.0.0.3", odlwebport="8080", - odlrestconfport="8181"): + def _test_multiple_suites(self, suites, + status=testcase.TestCase.EX_OK, + exception=None, **kwargs): + odlip = kwargs['odlip'] if 'odlip' in kwargs else '127.0.0.3' + odlwebport = kwargs['odlwebport'] if 'odlwebport' in kwargs else '8080' + odlrestconfport = (kwargs['odlrestconfport'] + if 'odlrestconfport' in kwargs else '8181') with mock.patch('functest.utils.openstack_utils.get_endpoint', side_effect=self._fake_url_for): if exception: @@ -380,31 +433,31 @@ class ODLTesting(unittest.TestCase): ospassword=self._os_password, ostenantname=self._os_tenantname, osusername=self._os_username) - def test_run_exception(self): + def test_exc(self): with mock.patch('functest.utils.openstack_utils.get_endpoint', side_effect=auth_plugins.MissingAuthPlugin()): self.assertEqual(self.test.run(), testcase.TestCase.EX_RUN_ERROR) - def test_run_missing_os_auth_url(self): - self._test_run_missing_env_var("OS_AUTH_URL") + def test_no_os_auth_url(self): + self._test_no_env_var("OS_AUTH_URL") - def test_run_missing_os_username(self): - self._test_run_missing_env_var("OS_USERNAME") + def test_no_os_username(self): + self._test_no_env_var("OS_USERNAME") - def test_run_missing_os_password(self): - self._test_run_missing_env_var("OS_PASSWORD") + def test_no_os_password(self): + self._test_no_env_var("OS_PASSWORD") - def test_run_missing_os_tenant_name(self): - self._test_run_missing_env_var("OS_TENANT_NAME") + def test_no_os_tenant_name(self): + self._test_no_env_var("OS_TENANT_NAME") - def test_run_main_false(self): + def test_main_false(self): os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip self._test_run(testcase.TestCase.EX_RUN_ERROR, odlip=self._sdn_controller_ip, odlwebport=self._odl_webport) - def test_run_main_exception(self): + def test_main_exc(self): with self.assertRaises(Exception): os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip self._test_run(status=testcase.TestCase.EX_RUN_ERROR, @@ -412,147 +465,155 @@ class ODLTesting(unittest.TestCase): odlip=self._sdn_controller_ip, odlwebport=self._odl_webport) - def test_run_missing_sdn_controller_ip(self): + def test_no_sdn_controller_ip(self): with mock.patch('functest.utils.openstack_utils.get_endpoint', side_effect=self._fake_url_for): self.assertEqual(self.test.run(), testcase.TestCase.EX_RUN_ERROR) - def test_run_without_installer_type(self): + def test_without_installer_type(self): os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip self._test_run(testcase.TestCase.EX_OK, odlip=self._sdn_controller_ip, odlwebport=self._odl_webport) - def test_run_redefining_suites(self): + def test_suites(self): os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip - self._test_run_defining_multiple_suites( + self._test_multiple_suites( [odl.ODLTests.basic_suite_dir], testcase.TestCase.EX_OK, odlip=self._sdn_controller_ip, odlwebport=self._odl_webport) - def test_run_fuel(self): + def test_fuel(self): os.environ["INSTALLER_TYPE"] = "fuel" self._test_run(testcase.TestCase.EX_OK, odlip=self._neutron_ip, odlwebport='8282') - def test_run_apex_missing_sdn_controller_ip(self): + def test_apex_no_controller_ip(self): 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.TestCase.EX_RUN_ERROR) - def test_run_apex(self): + def test_apex(self): os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip os.environ["INSTALLER_TYPE"] = "apex" self._test_run(testcase.TestCase.EX_OK, odlip=self._sdn_controller_ip, odlwebport='8081', odlrestconfport='8081') - def test_run_netvirt_missing_sdn_controller_ip(self): + def test_netvirt_no_controller_ip(self): with mock.patch('functest.utils.openstack_utils.get_endpoint', side_effect=self._fake_url_for): os.environ["INSTALLER_TYPE"] = "netvirt" self.assertEqual(self.test.run(), testcase.TestCase.EX_RUN_ERROR) - def test_run_netvirt(self): + def test_netvirt(self): os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip os.environ["INSTALLER_TYPE"] = "netvirt" self._test_run(testcase.TestCase.EX_OK, odlip=self._sdn_controller_ip, odlwebport='8081', odlrestconfport='8081') - def test_run_joid_missing_sdn_controller(self): + def test_joid_no_controller_ip(self): 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.TestCase.EX_RUN_ERROR) - def test_run_joid(self): + def test_joid(self): os.environ["SDN_CONTROLLER"] = self._sdn_controller_ip os.environ["INSTALLER_TYPE"] = "joid" self._test_run(testcase.TestCase.EX_OK, odlip=self._sdn_controller_ip, odlwebport='8080') - def test_run_compass(self, *args): + def test_compass(self): os.environ["INSTALLER_TYPE"] = "compass" self._test_run(testcase.TestCase.EX_OK, odlip=self._neutron_ip, odlwebport='8181') - def test_argparser_default(self): - parser = odl.ODLParser() - self.assertEqual(parser.parse_args(), self.defaultargs) - def test_argparser_basic(self): +class ODLArgParserTesting(ODLTesting): + + """The class testing ODLParser.""" + # pylint: disable=missing-docstring + + def setUp(self): + self.parser = odl.ODLParser() + super(ODLArgParserTesting, self).setUp() + + def test_default(self): + self.assertEqual(self.parser.parse_args(), self.defaultargs) + + def test_basic(self): self.defaultargs['neutronip'] = self._neutron_ip self.defaultargs['odlip'] = self._sdn_controller_ip - parser = odl.ODLParser() - self.assertEqual(parser.parse_args( - ["--neutronip={}".format(self._neutron_ip), - "--odlip={}".format(self._sdn_controller_ip) - ]), self.defaultargs) + self.assertEqual( + self.parser.parse_args( + ["--neutronip={}".format(self._neutron_ip), + "--odlip={}".format(self._sdn_controller_ip)]), + self.defaultargs) @mock.patch('sys.stderr', new_callable=StringIO.StringIO) - def test_argparser_fail(self, *args): + def test_fail(self, mock_method): self.defaultargs['foo'] = 'bar' - parser = odl.ODLParser() with self.assertRaises(SystemExit): - parser.parse_args(["--foo=bar"]) + self.parser.parse_args(["--foo=bar"]) + mock_method.assert_called_once_with() - def _test_argparser(self, arg, value): + def _test_arg(self, arg, value): self.defaultargs[arg] = value - parser = odl.ODLParser() - self.assertEqual(parser.parse_args(["--{}={}".format(arg, value)]), - self.defaultargs) + self.assertEqual( + self.parser.parse_args(["--{}={}".format(arg, value)]), + self.defaultargs) - def test_argparser_odlusername(self): - self._test_argparser('odlusername', 'foo') + def test_odlusername(self): + self._test_arg('odlusername', 'foo') - def test_argparser_odlpassword(self): - self._test_argparser('odlpassword', 'foo') + def test_odlpassword(self): + self._test_arg('odlpassword', 'foo') - def test_argparser_osauthurl(self): - self._test_argparser('osauthurl', 'http://127.0.0.4:5000/v2') + def test_osauthurl(self): + self._test_arg('osauthurl', 'http://127.0.0.4:5000/v2') - def test_argparser_neutronip(self): - self._test_argparser('neutronip', '127.0.0.4') + def test_neutronip(self): + self._test_arg('neutronip', '127.0.0.4') - def test_argparser_osusername(self): - self._test_argparser('osusername', 'foo') + def test_osusername(self): + self._test_arg('osusername', 'foo') - def test_argparser_ostenantname(self): - self._test_argparser('ostenantname', 'foo') + def test_ostenantname(self): + self._test_arg('ostenantname', 'foo') - def test_argparser_ospassword(self): - self._test_argparser('ospassword', 'foo') + def test_ospassword(self): + self._test_arg('ospassword', 'foo') - def test_argparser_odlip(self): - self._test_argparser('odlip', '127.0.0.4') + def test_odlip(self): + self._test_arg('odlip', '127.0.0.4') - def test_argparser_odlwebport(self): - self._test_argparser('odlwebport', '80') + def test_odlwebport(self): + self._test_arg('odlwebport', '80') - def test_argparser_odlrestconfport(self): - self._test_argparser('odlrestconfport', '80') + def test_odlrestconfport(self): + self._test_arg('odlrestconfport', '80') - def test_argparser_pushtodb(self): + def test_pushtodb(self): self.defaultargs['pushtodb'] = True - parser = odl.ODLParser() - self.assertEqual(parser.parse_args(["--{}".format('pushtodb')]), + self.assertEqual(self.parser.parse_args(["--{}".format('pushtodb')]), self.defaultargs) - def test_argparser_multiple_args(self): + def test_multiple_args(self): self.defaultargs['neutronip'] = self._neutron_ip self.defaultargs['odlip'] = self._sdn_controller_ip - parser = odl.ODLParser() - self.assertEqual(parser.parse_args( - ["--neutronip={}".format(self._neutron_ip), - "--odlip={}".format(self._sdn_controller_ip) - ]), self.defaultargs) + self.assertEqual( + self.parser.parse_args( + ["--neutronip={}".format(self._neutron_ip), + "--odlip={}".format(self._sdn_controller_ip)]), + self.defaultargs) if __name__ == "__main__": diff --git a/functest/tests/unit/opnfv_tests/openstack/tempest/test_conf_utils.py b/functest/tests/unit/opnfv_tests/openstack/tempest/test_conf_utils.py index caf21925..8ca5cc5b 100644 --- a/functest/tests/unit/opnfv_tests/openstack/tempest/test_conf_utils.py +++ b/functest/tests/unit/opnfv_tests/openstack/tempest/test_conf_utils.py @@ -37,7 +37,6 @@ class OSTempestConfUtilsTesting(unittest.TestCase): self.assertTrue(msg in context) def test_create_tempest_resources_missing_image(self): - CONST.tempest_use_custom_images = 'test_image' with mock.patch('functest.opnfv_tests.openstack.tempest.conf_utils.' 'os_utils.get_keystone_client', return_value=mock.Mock()), \ @@ -54,13 +53,18 @@ class OSTempestConfUtilsTesting(unittest.TestCase): 'os_utils.get_or_create_image', return_value=(mock.Mock(), None)), \ self.assertRaises(Exception) as context: + + CONST.tempest_use_custom_images = True conf_utils.create_tempest_resources() msg = 'Failed to create image' self.assertTrue(msg in context) + CONST.tempest_use_custom_images = False + conf_utils.create_tempest_resources(use_custom_images=True) + msg = 'Failed to create image' + self.assertTrue(msg in context) + def test_create_tempest_resources_missing_flavor(self): - CONST.tempest_use_custom_images = 'test_image' - CONST.tempest_use_custom_flavors = 'test_flavour' with mock.patch('functest.opnfv_tests.openstack.tempest.conf_utils.' 'os_utils.get_keystone_client', return_value=mock.Mock()), \ @@ -80,10 +84,18 @@ class OSTempestConfUtilsTesting(unittest.TestCase): 'os_utils.get_or_create_flavor', return_value=(mock.Mock(), None)), \ self.assertRaises(Exception) as context: + CONST.tempest_use_custom_images = True + CONST.tempest_use_custom_flavors = True conf_utils.create_tempest_resources() msg = 'Failed to create flavor' self.assertTrue(msg in context) + CONST.tempest_use_custom_images = True + CONST.tempest_use_custom_flavors = False + conf_utils.create_tempest_resources(use_custom_flavors=False) + msg = 'Failed to create flavor' + self.assertTrue(msg in context) + def test_get_verifier_id_missing_verifier(self): CONST.tempest_deployment_name = 'test_deploy_name' with mock.patch('functest.opnfv_tests.openstack.tempest.' @@ -153,6 +165,210 @@ class OSTempestConfUtilsTesting(unittest.TestCase): self.assertTrue(m1.called) self.assertTrue(m2.called) + def test_get_repo_tag_default(self): + mock_popen = mock.Mock() + attrs = {'stdout.readline.return_value': 'test_tag'} + mock_popen.configure_mock(**attrs) + + with mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.subprocess.Popen', + return_value=mock_popen): + self.assertEqual(conf_utils.get_repo_tag('test_repo'), + 'test_tag') + + def test_backup_tempest_config_default(self): + with mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.os.path.exists', + return_value=False), \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.os.makedirs') as m1, \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.shutil.copyfile') as m2: + conf_utils.backup_tempest_config('test_conf_file') + self.assertTrue(m1.called) + self.assertTrue(m2.called) + + with mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.os.path.exists', + return_value=True), \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.shutil.copyfile') as m2: + conf_utils.backup_tempest_config('test_conf_file') + self.assertTrue(m2.called) + + def test_configure_tempest_default(self): + with mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.configure_verifier', + return_value='test_conf_file'), \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.configure_tempest_update_params') as m1, \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.configure_tempest_multisite_params') as m2: + conf_utils.configure_tempest('test_dep_dir', + MODE='feature_multisite') + self.assertTrue(m1.called) + self.assertTrue(m2.called) + + with mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.configure_verifier', + return_value='test_conf_file'), \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.configure_tempest_update_params') as m1: + conf_utils.configure_tempest('test_dep_dir') + self.assertTrue(m1.called) + self.assertTrue(m2.called) + + def test_configure_tempest_defcore_default(self): + img_flavor_dict = {'image_id': 'test_image_id', + 'flavor_id': 'test_flavor_id', + 'image_id_alt': 'test_image_alt_id', + 'flavor_id_alt': 'test_flavor_alt_id'} + with mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.configure_verifier', + return_value='test_conf_file'), \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.configure_tempest_update_params'), \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.ConfigParser.RawConfigParser.' + 'set') as mset, \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.ConfigParser.RawConfigParser.' + 'read') as mread, \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.ConfigParser.RawConfigParser.' + 'write') as mwrite, \ + mock.patch('__builtin__.open', mock.mock_open()), \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.shutil.copyfile'): + CONST.dir_functest_test = 'test_dir' + CONST.refstack_tempest_conf_path = 'test_path' + conf_utils.configure_tempest_defcore('test_dep_dir', + img_flavor_dict) + mset.assert_any_call('compute', 'image_ref', 'test_image_id') + mset.assert_any_call('compute', 'image_ref_alt', + 'test_image_alt_id') + mset.assert_any_call('compute', 'flavor_ref', 'test_flavor_id') + mset.assert_any_call('compute', 'flavor_ref_alt', + 'test_flavor_alt_id') + self.assertTrue(mread.called) + self.assertTrue(mwrite.called) + + def _test_missing_param(self, params, image_id, flavor_id): + with mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.ConfigParser.RawConfigParser.' + 'set') as mset, \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.ConfigParser.RawConfigParser.' + 'read') as mread, \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.ConfigParser.RawConfigParser.' + 'write') as mwrite, \ + mock.patch('__builtin__.open', mock.mock_open()), \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.backup_tempest_config'): + CONST.dir_functest_test = 'test_dir' + CONST.OS_ENDPOINT_TYPE = None + conf_utils.\ + configure_tempest_update_params('test_conf_file', + IMAGE_ID=image_id, + FLAVOR_ID=flavor_id) + mset.assert_any_call(params[0], params[1], params[2]) + self.assertTrue(mread.called) + self.assertTrue(mwrite.called) + + def test_configure_tempest_update_params_missing_image_id(self): + CONST.tempest_use_custom_images = True + self._test_missing_param(('compute', 'image_ref', + 'test_image_id'), 'test_image_id', + None) + + def test_configure_tempest_update_params_missing_image_id_alt(self): + CONST.tempest_use_custom_images = True + conf_utils.IMAGE_ID_ALT = 'test_image_id_alt' + self._test_missing_param(('compute', 'image_ref_alt', + 'test_image_id_alt'), None, None) + + def test_configure_tempest_update_params_missing_flavor_id(self): + CONST.tempest_use_custom_flavors = True + self._test_missing_param(('compute', 'flavor_ref', + 'test_flavor_id'), None, + 'test_flavor_id') + + def test_configure_tempest_update_params_missing_flavor_id_alt(self): + CONST.tempest_use_custom_flavors = True + conf_utils.FLAVOR_ID_ALT = 'test_flavor_id_alt' + self._test_missing_param(('compute', 'flavor_ref_alt', + 'test_flavor_id_alt'), None, + None) + + def test_configure_verifier_missing_temp_conf_file(self): + with mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.os.path.isfile', + return_value=False), \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.ft_utils.execute_command') as mexe, \ + self.assertRaises(Exception) as context: + conf_utils.configure_verifier('test_dep_dir') + mexe.assert_any_call("rally verify configure-verifier") + msg = ("Tempest configuration file 'test_dep_dir/tempest.conf'" + " NOT found.") + self.assertTrue(msg in context) + + def test_configure_verifier_default(self): + with mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.os.path.isfile', + return_value=True), \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.ft_utils.execute_command') as mexe: + self.assertEqual(conf_utils.configure_verifier('test_dep_dir'), + 'test_dep_dir/tempest.conf') + mexe.assert_any_call("rally verify configure-verifier " + "--reconfigure") + + def test_configure_tempest_multisite_params_without_fuel(self): + conf_utils.CI_INSTALLER_TYPE = 'not_fuel' + with mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.os_utils.get_endpoint', + return_value='kingbird_endpoint_url'), \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.ConfigParser.RawConfigParser.' + 'set') as mset, \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.ConfigParser.RawConfigParser.' + 'read') as mread, \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.ConfigParser.RawConfigParser.' + 'add_section') as msection, \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.ConfigParser.RawConfigParser.' + 'write') as mwrite, \ + mock.patch('__builtin__.open', mock.mock_open()), \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.backup_tempest_config'): + + conf_utils.configure_tempest_multisite_params('test_conf_file') + msection.assert_any_call("kingbird") + mset.assert_any_call('service_available', 'kingbird', 'true') + mset.assert_any_call('kingbird', 'endpoint_type', 'publicURL') + mset.assert_any_call('kingbird', 'TIME_TO_SYNC', '120') + mset.assert_any_call('kingbird', 'endpoint_url', + 'kingbird_endpoint_url') + self.assertTrue(mread.called) + self.assertTrue(mwrite.called) + + def test_install_verifier_ext_default(self): + with mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.get_repo_tag', + return_value='test_tag'), \ + mock.patch('functest.opnfv_tests.openstack.tempest.' + 'conf_utils.ft_utils.' + 'execute_command_raise') as mexe: + conf_utils.install_verifier_ext('test_path') + cmd = ("rally verify add-verifier-ext --source test_path " + "--version test_tag") + error_msg = ("Problem while adding verifier extension from" + " test_path") + mexe.assert_called_once_with(cmd, error_msg=error_msg) if __name__ == "__main__": unittest.main(verbosity=2) diff --git a/functest/tests/unit/opnfv_tests/openstack/tempest/test_tempest.py b/functest/tests/unit/opnfv_tests/openstack/tempest/test_tempest.py index 398c53bf..34031b40 100644 --- a/functest/tests/unit/opnfv_tests/openstack/tempest/test_tempest.py +++ b/functest/tests/unit/opnfv_tests/openstack/tempest/test_tempest.py @@ -13,6 +13,7 @@ import mock from functest.core import testcase from functest.opnfv_tests.openstack.tempest import tempest from functest.opnfv_tests.openstack.tempest import conf_utils +from functest.utils.constants import CONST class OSTempestTesting(unittest.TestCase): @@ -33,6 +34,14 @@ class OSTempestTesting(unittest.TestCase): 'conf_utils.get_verifier_deployment_dir', return_value='test_verifier_deploy_dir'): self.tempestcommon = tempest.TempestCommon() + self.tempestsmoke_serial = tempest.TempestSmokeSerial() + self.tempestsmoke_parallel = tempest.TempestSmokeParallel() + self.tempestfull_parallel = tempest.TempestFullParallel() + with mock.patch('functest.opnfv_tests.openstack.tempest.tempest.' + 'conf_utils.install_verifier_ext'): + self.tempestmultisite = tempest.TempestMultisite() + self.tempestcustom = tempest.TempestCustom() + self.tempestdefcore = tempest.TempestDefcore() @mock.patch('functest.opnfv_tests.openstack.tempest.tempest.logger.debug') def test_generate_test_list_defcore_mode(self, mock_logger_debug): @@ -100,6 +109,48 @@ class OSTempestTesting(unittest.TestCase): with self.assertRaises(Exception): self.tempestcommon.parse_verifier_result() + def test_apply_tempest_blacklist_no_blacklist(self): + with mock.patch('__builtin__.open', mock.mock_open()) as m, \ + mock.patch.object(self.tempestcommon, 'read_file', + return_value=['test1', 'test2']): + conf_utils.TEMPEST_BLACKLIST = Exception + CONST.INSTALLER_TYPE = 'installer_type' + CONST.DEPLOY_SCENARIO = 'deploy_scenario' + self.tempestcommon.apply_tempest_blacklist() + obj = m() + obj.write.assert_any_call('test1\n') + obj.write.assert_any_call('test2\n') + + def test_apply_tempest_blacklist_default(self): + item_dict = {'scenarios': ['deploy_scenario'], + 'installers': ['installer_type'], + 'tests': ['test2']} + with mock.patch('__builtin__.open', mock.mock_open()) as m, \ + mock.patch.object(self.tempestcommon, 'read_file', + return_value=['test1', 'test2']), \ + mock.patch('functest.opnfv_tests.openstack.tempest.tempest.' + 'yaml.safe_load', return_value=item_dict): + CONST.INSTALLER_TYPE = 'installer_type' + CONST.DEPLOY_SCENARIO = 'deploy_scenario' + self.tempestcommon.apply_tempest_blacklist() + obj = m() + obj.write.assert_any_call('test1\n') + self.assertFalse(obj.write.assert_any_call('test2\n')) + + @mock.patch('functest.opnfv_tests.openstack.tempest.tempest.logger.info') + def test_run_verifier_tests_default(self, mock_logger_info): + with mock.patch('__builtin__.open', mock.mock_open()), \ + mock.patch('__builtin__.iter', return_value=['\} tempest\.']), \ + mock.patch('functest.opnfv_tests.openstack.tempest.tempest.' + 'subprocess.Popen'): + conf_utils.TEMPEST_LIST = 'test_tempest_list' + cmd_line = ("rally verify start --load-list " + "test_tempest_list --detailed") + self.tempestcommon.run_verifier_tests() + mock_logger_info. \ + assert_any_call("Starting Tempest test suite: '%s'." + % cmd_line) + @mock.patch('functest.opnfv_tests.openstack.tempest.tempest.logger.info') def test_parse_verifier_result_default(self, mock_logger_info): self.tempestcommon.VERIFICATION_ID = 'test_uuid' diff --git a/functest/tests/unit/opnfv_tests/vnf/ims/test_clearwater.py b/functest/tests/unit/opnfv_tests/vnf/ims/test_clearwater.py index 527f12e5..18bebfdf 100644 --- a/functest/tests/unit/opnfv_tests/vnf/ims/test_clearwater.py +++ b/functest/tests/unit/opnfv_tests/vnf/ims/test_clearwater.py @@ -39,16 +39,48 @@ class ClearwaterTesting(unittest.TestCase): with mock.patch.object(self.clearwater.orchestrator, 'download_upload_and_deploy_blueprint', return_value=''): - self.clearwater.deploy_vnf(self.bp), + self.clearwater.deploy_vnf(self.bp) self.assertEqual(self.clearwater.deploy, True) def test_undeploy_vnf_deployment_passed(self): with mock.patch.object(self.clearwater.orchestrator, 'undeploy_deployment'): self.clearwater.deploy = True + self.clearwater.undeploy_vnf() + self.assertEqual(self.clearwater.deploy, False) + + def test_undeploy_vnf_deployment_with_undeploy(self): + with mock.patch.object(self.clearwater.orchestrator, + 'undeploy_deployment') as m: + self.clearwater.deploy = False + self.clearwater.undeploy_vnf(), + self.assertEqual(self.clearwater.deploy, False) + self.assertFalse(m.called) + + self.clearwater.orchestrator = None + self.clearwater.deploy = True + self.clearwater.undeploy_vnf(), + self.assertEqual(self.clearwater.deploy, True) + + self.clearwater.deploy = False self.clearwater.undeploy_vnf(), self.assertEqual(self.clearwater.deploy, False) + def test_set_methods(self): + self.clearwater.set_orchestrator(self.orchestrator) + self.assertTrue(self.clearwater.orchestrator, self.orchestrator) + self.clearwater.set_flavor_id('test_flavor_id') + self.assertTrue(self.clearwater.config['flavor_id'], 'test_flavor_id') + self.clearwater.set_image_id('test_image_id') + self.assertTrue(self.clearwater.config['image_id'], 'test_image_id') + self.clearwater.set_agent_user('test_user') + self.assertTrue(self.clearwater.config['agent_user'], 'test_user') + self.clearwater.set_external_network_name('test_network') + self.assertTrue(self.clearwater.config['external_network_name'], + 'test_network') + self.clearwater.set_public_domain('test_domain') + self.assertTrue(self.clearwater.config['public_domain'], + 'test_domain') if __name__ == "__main__": unittest.main(verbosity=2) diff --git a/functest/tests/unit/opnfv_tests/vnf/ims/test_cloudify_ims.py b/functest/tests/unit/opnfv_tests/vnf/ims/test_cloudify_ims.py index e25816f0..f47ea865 100644 --- a/functest/tests/unit/opnfv_tests/vnf/ims/test_cloudify_ims.py +++ b/functest/tests/unit/opnfv_tests/vnf/ims/test_cloudify_ims.py @@ -13,7 +13,7 @@ import mock from functest.opnfv_tests.vnf.ims import cloudify_ims -class ImsVnfTesting(unittest.TestCase): +class CloudifyImsTesting(unittest.TestCase): logging.disable(logging.CRITICAL) @@ -22,7 +22,7 @@ class ImsVnfTesting(unittest.TestCase): 'os.makedirs'), \ mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' 'get_config', return_value='config_value'): - self.ims_vnf = cloudify_ims.ImsVnf() + self.ims_vnf = cloudify_ims.CloudifyIms() self.neutron_client = mock.Mock() self.glance_client = mock.Mock() self.keystone_client = mock.Mock() @@ -419,94 +419,46 @@ class ImsVnfTesting(unittest.TestCase): self.ims_vnf.test_vnf() self.assertTrue(msg in context.exception) - def test_test_vnf_create_number_failure(self): - with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' - 'os.popen') as m, \ - mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' - 'requests.get'), \ - mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' - 'requests.post', - return_value=self.mock_post), \ - self.assertRaises(Exception) as context: - mock_obj = mock.Mock() - attrs = {'read.return_value': 'test_ip\n'} - mock_obj.configure_mock(**attrs) - m.return_value = mock_obj - - self.ims_vnf.test_vnf() - - msg = "Unable to create a number:" - self.assertTrue(msg in context.exception) - - def _get_post_status(self, url, cookies='', data=''): - ellis_url = "http://test_ellis_ip/session" - if url == ellis_url: - return self.mock_post_200 - return self.mock_post - def test_test_vnf_fail(self): with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' - 'os.popen') as m, \ - mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' - 'requests.get') as mock_get, \ - mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' - 'requests.post', - side_effect=self._get_post_status), \ - mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' - 'ft_utils.get_resolvconf_ns'), \ - mock.patch('__builtin__.open', mock.mock_open()), \ - mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' - 'subprocess.call'), \ - mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' - 'os.remove'), \ - mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' - 'json.load', return_value=''): - mock_obj = mock.Mock() - attrs = {'read.return_value': 'test_ip\n'} - mock_obj.configure_mock(**attrs) - m.return_value = mock_obj + 'os.popen'), \ + mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' + 'requests.get') as mock_get, \ + mock.patch.object(self.ims_vnf, 'config_ellis'), \ + mock.patch.object(self.ims_vnf, + 'run_clearwater_live_test') as clearwater_obj: + clearwater_obj.return_value = '' - mock_obj2 = mock.Mock() - attrs = {'json.return_value': {'outputs': - {'dns_ip': 'test_dns_ip', - 'ellis_ip': 'test_ellis_ip'}}} - mock_obj2.configure_mock(**attrs) - mock_get.return_value = mock_obj2 + mock_obj2 = mock.Mock() + attrs = {'json.return_value': {'outputs': + {'dns_ip': 'test_dns_ip', + 'ellis_ip': 'test_ellis_ip'}}} + mock_obj2.configure_mock(**attrs) + mock_get.return_value = mock_obj2 - self.assertEqual(self.ims_vnf.test_vnf(), - {'status': 'FAIL', 'result': ''}) + self.assertEqual(self.ims_vnf.test_vnf(), + {'status': 'FAIL', 'result': ''}) def test_test_vnf_pass(self): with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' - 'os.popen') as m, \ - mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' - 'requests.get') as mock_get, \ - mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' - 'requests.post', - side_effect=self._get_post_status), \ - mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' - 'ft_utils.get_resolvconf_ns'), \ - mock.patch('__builtin__.open', mock.mock_open()), \ - mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' - 'subprocess.call'), \ - mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' - 'os.remove'), \ - mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' - 'json.load', return_value='vims_test_result'): - mock_obj = mock.Mock() - attrs = {'read.return_value': 'test_ip\n'} - mock_obj.configure_mock(**attrs) - m.return_value = mock_obj - - mock_obj2 = mock.Mock() - attrs = {'json.return_value': {'outputs': - {'dns_ip': 'test_dns_ip', - 'ellis_ip': 'test_ellis_ip'}}} - mock_obj2.configure_mock(**attrs) - mock_get.return_value = mock_obj2 - - self.assertEqual(self.ims_vnf.test_vnf(), - {'status': 'PASS', 'result': 'vims_test_result'}) + 'os.popen'), \ + mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' + 'requests.get') as mock_get, \ + mock.patch.object(self.ims_vnf, 'config_ellis'), \ + mock.patch.object(self.ims_vnf, + 'run_clearwater_live_test') as clearwater_obj: + clearwater_obj.return_value = 'vims_test_result' + + mock_obj2 = mock.Mock() + attrs = {'json.return_value': {'outputs': + {'dns_ip': 'test_dns_ip', + 'ellis_ip': 'test_ellis_ip'}}} + mock_obj2.configure_mock(**attrs) + mock_get.return_value = mock_obj2 + + self.assertEqual(self.ims_vnf.test_vnf(), + {'status': 'PASS', + 'result': 'vims_test_result'}) def test_download_and_add_image_on_glance_incorrect_url(self): with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' diff --git a/functest/tests/unit/opnfv_tests/vnf/ims/test_ims_base.by b/functest/tests/unit/opnfv_tests/vnf/ims/test_ims_base.by new file mode 100644 index 00000000..9440bcdf --- /dev/null +++ b/functest/tests/unit/opnfv_tests/vnf/ims/test_ims_base.by @@ -0,0 +1,58 @@ +#!/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.opnfv_tests.vnf.ims import ims_base + + +class ClearwaterOnBoardingBaseTesting(unittest.TestCase): + + logging.disable(logging.CRITICAL) + + def setUp(self): + with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.' + 'os.makedirs'): + self.ims_vnf = ims_base.ClearwaterOnBoardingBase() + + self.mock_post = mock.Mock() + attrs = {'status_code': 201, + 'cookies': ""} + self.mock_post.configure_mock(**attrs) + + self.mock_post_200 = mock.Mock() + attrs = {'status_code': 200, + 'cookies': ""} + self.mock_post_200.configure_mock(**attrs) + + self.mock_post_500 = mock.Mock() + attrs = {'status_code': 500, + 'cookies': ""} + self.mock_post_200.configure_mock(**attrs) + + def test_create_ellis_number_failure(self): + with mock.patch('functest.opnfv_tests.vnf.ims.ims_base.' + 'requests.post', + return_value=self.mock_post_500), \ + self.assertRaises(Exception) as context: + self.ims_vnf.create_ellis_number() + + msg = "Unable to create a number:" + self.assertTrue(msg in context.exception) + + def _get_post_status(self, url, cookies='', data=''): + ellis_url = "http://test_ellis_ip/session" + if url == ellis_url: + return self.mock_post_200 + return self.mock_post + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/functest/tests/unit/opnfv_tests/vnf/ims/test_orchestrator_cloudify.py b/functest/tests/unit/opnfv_tests/vnf/ims/test_orchestrator_cloudify.py index 620b0216..bf6d483f 100644 --- a/functest/tests/unit/opnfv_tests/vnf/ims/test_orchestrator_cloudify.py +++ b/functest/tests/unit/opnfv_tests/vnf/ims/test_orchestrator_cloudify.py @@ -6,6 +6,7 @@ # http://www.apache.org/licenses/LICENSE-2.0 import logging +import subprocess32 as subprocess import unittest import mock @@ -117,6 +118,60 @@ class ImsVnfTesting(unittest.TestCase): 'dest'), True) + def test_execute_command_failed(self): + with mock.patch('__builtin__.open', + mock.mock_open(read_data='test_data\n')): + subprocess.call = mock.create_autospec(subprocess.call, + return_value=0) + mock_log = mock.Mock() + cmd = 'test_cmd -e test_env bash_script' + ret = orchestrator_cloudify.execute_command(cmd, mock_log, + timeout=100) + self.assertEqual(ret, False) + + def test_execute_command_default(self): + with mock.patch('__builtin__.open', + mock.mock_open(read_data='test_data\n')): + subprocess.call = mock. \ + create_autospec(subprocess.call, + return_value=subprocess.TimeoutExpired) + mock_log = mock.Mock() + cmd = 'test_cmd -e test_env bash_script' + ret = orchestrator_cloudify.execute_command(cmd, mock_log, + timeout=100) + self.assertEqual(ret, ['test_data\n']) + + def test_set_methods(self): + self.orchestrator.set_credentials('test_username', 'test_password', + 'test_tenant_name', 'test_auth_url') + self.assertTrue(self.orchestrator.config['keystone_username'], + 'test_username') + self.assertTrue(self.orchestrator.config['keystone_password'], + 'test_password') + self.assertTrue(self.orchestrator.config['keystone_url'], + 'test_auth_url') + self.assertTrue(self.orchestrator.config['keystone_tenant_name'], + 'test_tenant_name') + self.orchestrator.set_flavor_id('test_flavor_id') + self.assertTrue(self.orchestrator.config['flavor_id'], + 'test_flavor_id') + self.orchestrator.set_image_id('test_image_id') + self.assertTrue(self.orchestrator.config['image_id'], 'test_image_id') + self.orchestrator.set_external_network_name('test_network') + self.assertTrue(self.orchestrator.config['external_network_name'], + 'test_network') + self.orchestrator.set_ssh_user('test_user') + self.assertTrue(self.orchestrator.config['ssh_user'], + 'test_user') + self.orchestrator.set_nova_url('test_nova_url') + self.assertTrue(self.orchestrator.config['nova_url'], + 'test_nova_url') + self.orchestrator.set_neutron_url('test_neutron_url') + self.assertTrue(self.orchestrator.config['neutron_url'], + 'test_neutron_url') + self.orchestrator.set_nameservers(['test_subnet']) + self.assertTrue(self.orchestrator.config['dns_subnet_1'], + 'test_subnet') if __name__ == "__main__": unittest.main(verbosity=2) diff --git a/functest/tests/unit/utils/test_functest_logger.py b/functest/tests/unit/utils/test_functest_logger.py new file mode 100644 index 00000000..42e41a14 --- /dev/null +++ b/functest/tests/unit/utils/test_functest_logger.py @@ -0,0 +1,48 @@ +#!/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.utils import functest_logger +from functest.utils.constants import CONST + + +class OSUtilsLogger(unittest.TestCase): + + logging.disable(logging.CRITICAL) + + def setUp(self): + with mock.patch('__builtin__.open', mock.mock_open()): + with mock.patch('functest.utils.functest_logger.os.path.exists', + return_value=True), \ + mock.patch('functest.utils.functest_logger.' + 'json.load'), \ + mock.patch('functest.utils.functest_logger.' + 'logging.config.dictConfig') as m: + self.logger = functest_logger.Logger('os_utils') + self.assertTrue(m.called) + with mock.patch('functest.utils.functest_logger.os.path.exists', + return_value=False), \ + mock.patch('functest.utils.functest_logger.' + 'logging.basicConfig') as m: + self.logger = functest_logger.Logger('os_utils') + self.assertTrue(m.called) + + def test_is_debug_false(self): + CONST.CI_DEBUG = False + self.assertFalse(self.logger.is_debug()) + + def test_is_debug_true(self): + CONST.CI_DEBUG = "True" + self.assertTrue(self.logger.is_debug()) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/functest/tests/unit/utils/test_openstack_tacker.py b/functest/tests/unit/utils/test_openstack_tacker.py index dc717258..37d77a18 100644 --- a/functest/tests/unit/utils/test_openstack_tacker.py +++ b/functest/tests/unit/utils/test_openstack_tacker.py @@ -6,9 +6,11 @@ # http://www.apache.org/licenses/LICENSE-2.0 import logging -import mock import unittest +import mock +from tackerclient.v1_0 import client as tackerclient + from functest.utils import openstack_tacker from functest.tests.unit import test_utils @@ -56,6 +58,13 @@ class OSTackerTesting(unittest.TestCase): } return cred_dict + def test_get_tacker_client(self): + with mock.patch('functest.utils.openstack_tacker.' + 'os_utils.get_session'): + tackerclient.Client = mock.Mock + ret = openstack_tacker.get_tacker_client() + self.assertTrue(isinstance(ret, mock.Mock)) + def test_get_id_from_name(self): with mock.patch.object(self.tacker_client, 'get', return_value=self.getresponse): @@ -183,8 +192,16 @@ class OSTackerTesting(unittest.TestCase): vnfd_name=self.vnfd) self.assertEqual(resp, self.vnfd) - # TODO: Exception('You need to provide an VNFD' - # 'id or name') AssertionError + def test_delete_vnfd_missing_vnfd_name(self): + with mock.patch('functest.utils.openstack_tacker.get_vnfd_id', + return_value=self.vnfd), \ + self.assertRaises(Exception) as context: + resp = openstack_tacker.delete_vnfd(self.tacker_client, + vnfd_id=None, + vnfd_name=None) + self.assertIsNone(resp) + msg = 'You need to provide VNFD id or VNFD name' + self.assertTrue(msg in context) @mock.patch('functest.utils.openstack_tacker.logger.error') def test_delete_vnfd_exception(self, mock_logger_error): @@ -253,7 +270,47 @@ class OSTackerTesting(unittest.TestCase): "client")) self.assertIsNone(resp) - # TODO: wait_for_vnf + def test_wait_for_vnf_vnf_retrieval_failed(self): + with mock.patch('functest.utils.openstack_tacker.get_vnf', + return_value=None), \ + self.assertRaises(Exception) as context: + openstack_tacker.wait_for_vnf(self.tacker_client, + vnf_id='vnf_id', + vnf_name='vnf_name') + msg = ("Could not retrieve VNF - id='vnf_id', " + "name='vnf_name'") + self.assertTrue(msg in context) + with mock.patch('functest.utils.openstack_tacker.get_vnf', + side_effect=Exception): + ret = openstack_tacker.wait_for_vnf(self.tacker_client, + vnf_id='vnf_id', + vnf_name='vnf_name') + self.assertEqual(ret, None) + + def test_wait_for_vnf_vnf_status_error(self): + vnf = {'id': 'vnf_id', + 'status': 'ERROR'} + with mock.patch('functest.utils.openstack_tacker.get_vnf', + return_value=vnf), \ + self.assertRaises(Exception) as context: + openstack_tacker.wait_for_vnf(self.tacker_client, + vnf_id='vnf_id', + vnf_name='vnf_name') + msg = ('Error when booting vnf vnf_id') + self.assertTrue(msg in context) + + def test_wait_for_vnf_vnf_timeout(self): + vnf = {'id': 'vnf_id', + 'status': 'PENDING_CREATE'} + with mock.patch('functest.utils.openstack_tacker.get_vnf', + return_value=vnf), \ + self.assertRaises(Exception) as context: + openstack_tacker.wait_for_vnf(self.tacker_client, + vnf_id='vnf_id', + vnf_name='vnf_name', + timeout=2) + msg = ('Timeout when booting vnf vnf_id') + self.assertTrue(msg in context) def test_delete_vnf(self): with mock.patch('functest.utils.openstack_tacker.get_vnf_id', @@ -265,8 +322,13 @@ class OSTackerTesting(unittest.TestCase): vnf_name=self.vnf) self.assertEqual(resp, self.vnf) - # TODO: Exception('You need to provide an VNF' - # 'classifier id or name') AssertionError + def test_delete_vnf_missing_vnf_name(self): + with self.assertRaises(Exception) as context: + openstack_tacker.delete_vnf(self.tacker_client, + vnf_id=None, + vnf_name=None) + msg = 'You need to provide a VNF id or name' + self.assertTrue(msg in context) @mock.patch('functest.utils.openstack_tacker.logger.error') def test_delete_vnf_exception(self, mock_logger_error): @@ -345,8 +407,13 @@ class OSTackerTesting(unittest.TestCase): sfc_name=self.sfc) self.assertEqual(resp, self.sfc) - # TODO: Exception('You need to provide an SFC' - # 'id or name') AssertionError + def test_delete_sfc_missing_sfc_name(self): + with self.assertRaises(Exception) as context: + openstack_tacker.delete_sfc(self.tacker_client, + sfc_id=None, + sfc_name=None) + msg = 'You need to provide an SFC id or name' + self.assertTrue(msg in context) @mock.patch('functest.utils.openstack_tacker.logger.error') def test_delete_sfc_exception(self, mock_logger_error): @@ -431,8 +498,13 @@ class OSTackerTesting(unittest.TestCase): sfc_clf_name=cl) self.assertEqual(resp, cl) - # TODO: Exception('You need to provide an SFC' - # 'classifier id or name') AssertionError + def test_delete_sfc_classifier_missing_sfc_name(self): + with self.assertRaises(Exception) as context: + openstack_tacker.delete_vnf(self.tacker_client, + sfc_clf_id=None, + sfc_clf_name=None) + msg = 'You need to provide an SFCclassifier id or name' + self.assertTrue(msg in context) @mock.patch('functest.utils.openstack_tacker.logger.error') def test_delete_sfc_classifier_exception(self, mock_logger_error): diff --git a/functest/tests/unit/utils/test_openstack_utils.py b/functest/tests/unit/utils/test_openstack_utils.py index 673ad5e2..7f3995d0 100644 --- a/functest/tests/unit/utils/test_openstack_utils.py +++ b/functest/tests/unit/utils/test_openstack_utils.py @@ -229,6 +229,12 @@ class OSUtilsTesting(unittest.TestCase): self.sec_group = {'id': 'sec_group_id', 'name': 'test_sec_group'} + self.sec_group_rule = {'id': 'sec_group_rule_id', + 'direction': 'direction', + 'protocol': 'protocol', + 'port_range_max': 'port_max', + 'security_group_id': self.sec_group['id'], + 'port_range_min': 'port_min'} self.neutron_floatingip = {'id': 'fip_id', 'floating_ip_address': 'test_ip'} self.neutron_client = mock.Mock() @@ -260,6 +266,9 @@ class OSUtilsTesting(unittest.TestCase): 'show_bgpvpn.return_value': self.mock_return, 'list_security_groups.return_value': {'security_groups': [self.sec_group]}, + 'list_security_group_rules.' + 'return_value': {'security_group_rules': + [self.sec_group_rule]}, 'create_security_group_rule.return_value': mock.Mock(), 'create_security_group.return_value': {'security_group': self.sec_group}, @@ -1247,6 +1256,52 @@ class OSUtilsTesting(unittest.TestCase): 'test_sec_group'), 'sec_group_id') + def test_get_security_group_rules_default(self): + self.assertEqual(openstack_utils. + get_security_group_rules(self.neutron_client, + self.sec_group['id']), + [self.sec_group_rule]) + + @mock.patch('functest.utils.openstack_utils.logger.error') + def test_get_security_group_rules_exception(self, mock_logger_error): + self.assertEqual(openstack_utils. + get_security_group_rules(Exception, + 'sec_group_id'), + None) + self.assertTrue(mock_logger_error.called) + + def test_check_security_group_rules_not_exists(self): + self.assertEqual(openstack_utils. + check_security_group_rules(self.neutron_client, + 'sec_group_id_2', + 'direction', + 'protocol', + 'port_min', + 'port_max'), + True) + + def test_check_security_group_rules_exists(self): + self.assertEqual(openstack_utils. + check_security_group_rules(self.neutron_client, + self.sec_group['id'], + 'direction', + 'protocol', + 'port_min', + 'port_max'), + False) + + @mock.patch('functest.utils.openstack_utils.logger.error') + def test_check_security_group_rules_exception(self, mock_logger_error): + self.assertEqual(openstack_utils. + check_security_group_rules(Exception, + 'sec_group_id', + 'direction', + 'protocol', + 'port_max', + 'port_min'), + None) + self.assertTrue(mock_logger_error.called) + def test_create_security_group_default(self): self.assertEqual(openstack_utils. create_security_group(self.neutron_client, |