diff options
Diffstat (limited to 'dovetail/tests')
| -rw-r--r-- | dovetail/tests/unit/cli/commands/test_cli_testcase.py | 6 | ||||
| -rw-r--r-- | dovetail/tests/unit/cli/test_cli_base.py | 8 | ||||
| -rw-r--r-- | dovetail/tests/unit/cmd_config.yml | 17 | ||||
| -rw-r--r-- | dovetail/tests/unit/test_container.py | 387 | ||||
| -rw-r--r-- | dovetail/tests/unit/test_parser.py | 10 | ||||
| -rw-r--r-- | dovetail/tests/unit/test_report.py | 840 | ||||
| -rw-r--r-- | dovetail/tests/unit/test_run.py | 136 | ||||
| -rw-r--r-- | dovetail/tests/unit/test_test_runner.py | 233 | ||||
| -rw-r--r-- | dovetail/tests/unit/test_testcase.py | 203 | ||||
| -rw-r--r-- | dovetail/tests/unit/test_testcase.yaml | 11 | ||||
| -rw-r--r-- | dovetail/tests/unit/utils/test_dovetail_config.py | 2 | ||||
| -rw-r--r-- | dovetail/tests/unit/utils/test_dovetail_logger.py | 8 | ||||
| -rw-r--r-- | dovetail/tests/unit/utils/test_dovetail_utils.py | 219 |
13 files changed, 1273 insertions, 807 deletions
diff --git a/dovetail/tests/unit/cli/commands/test_cli_testcase.py b/dovetail/tests/unit/cli/commands/test_cli_testcase.py index 2a1feb64..324db640 100644 --- a/dovetail/tests/unit/cli/commands/test_cli_testcase.py +++ b/dovetail/tests/unit/cli/commands/test_cli_testcase.py @@ -34,7 +34,7 @@ class CliTestcaseTesting(unittest.TestCase): testcase.run(options) mock_path.dirname.assert_called_once() - cmd = 'python %s/run.py %s' % (repo_dir, options) + cmd = 'python3 %s/run.py %s' % (repo_dir, options) mock_utils.exec_cmd.assert_called_once_with( cmd, exit_on_error=True, exec_msg_on=False, info=True) @@ -60,7 +60,7 @@ class CliTestcaseTesting(unittest.TestCase): mock_click.echo.assert_called_once_with( 'testcase %s not exist or not supported' % testcase_name) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.cli.commands.cli_testcase.constants') @patch('os.path') @patch('dovetail.cli.commands.cli_testcase.click') @@ -85,7 +85,7 @@ class CliTestcaseTesting(unittest.TestCase): mock_path.isfile.assert_called_once_with(testcase_whole_path) mock_click.echo.assert_called_once_with(file_data) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.cli.commands.cli_testcase.constants') @patch('os.path') @patch('dovetail.cli.commands.cli_testcase.click') diff --git a/dovetail/tests/unit/cli/test_cli_base.py b/dovetail/tests/unit/cli/test_cli_base.py index 80b7e7b3..9b06426c 100644 --- a/dovetail/tests/unit/cli/test_cli_base.py +++ b/dovetail/tests/unit/cli/test_cli_base.py @@ -24,7 +24,7 @@ class CliBaseTesting(unittest.TestCase): runner = CliRunner() result = runner.invoke(cli_base.cli, []) - self.assertEquals(result.exit_code, 0) + self.assertEqual(result.exit_code, 0) def test_testcase_list(self, mock_testcase): testsuite = 'suite' @@ -33,7 +33,7 @@ class CliBaseTesting(unittest.TestCase): result = runner.invoke(cli_base.testcase_list, [testsuite]) mock_testcase.list_testsuites.assert_called_once_with(testsuite) - self.assertEquals(result.exit_code, 0) + self.assertEqual(result.exit_code, 0) def test_testcase_show(self, mock_testcase): testcase = 'case' @@ -42,7 +42,7 @@ class CliBaseTesting(unittest.TestCase): result = runner.invoke(cli_base.testcase_show, [testcase]) mock_testcase.show_testcase.assert_called_once_with(testcase) - self.assertEquals(result.exit_code, 0) + self.assertEqual(result.exit_code, 0) def test_testcase_run(self, mock_testcase): run_args = ('arga', 'argb') @@ -52,4 +52,4 @@ class CliBaseTesting(unittest.TestCase): expected = ' '.join(run_args) mock_testcase.run.assert_called_once_with(expected) - self.assertEquals(result.exit_code, 0) + self.assertEqual(result.exit_code, 0) diff --git a/dovetail/tests/unit/cmd_config.yml b/dovetail/tests/unit/cmd_config.yml index 4a1439f6..405aabce 100644 --- a/dovetail/tests/unit/cmd_config.yml +++ b/dovetail/tests/unit/cmd_config.yml @@ -1,3 +1,12 @@ +############################################################################## +# Copyright (c) 2019 opnfv. +# +# 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 +############################################################################## + --- cli: arguments: @@ -22,3 +31,11 @@ cli: flags: - '--report' is_flag: 'True' + opnfvci: + flags: + - '--opnfv-ci' + is_flag: 'True' + noapivalidation: + flags: + - '--no-api-validation' + is_flag: 'True' diff --git a/dovetail/tests/unit/test_container.py b/dovetail/tests/unit/test_container.py index 70e01d8e..86da9d3c 100644 --- a/dovetail/tests/unit/test_container.py +++ b/dovetail/tests/unit/test_container.py @@ -10,6 +10,7 @@ import unittest from mock import patch, call, Mock +import docker from dovetail.container import Container @@ -19,6 +20,7 @@ __author__ = 'Stamatis Katsaounis <mokats@intracom-telecom.com>' class ContainerTesting(unittest.TestCase): def setUp(self): + self.patcher1 = patch.object(docker, 'from_env') testcase = patch.object(Container, 'testcase') testcase.testcase = {'validate': { 'type': 'bottlenecks'}} @@ -28,28 +30,13 @@ class ContainerTesting(unittest.TestCase): val_type_obj = Mock() val_type_obj.return_value = 'bottlenecks' testcase.validate_type = val_type_obj + self.client = self.patcher1.start().return_value self.container = Container(testcase) self.logger = Mock() self.container.logger = self.logger def tearDown(self): - pass - - @patch('dovetail.container.dt_cfg') - @patch.object(Container, 'docker_copy') - def test_set_vnftest_conf_file(self, mock_copy, mock_config): - source_file = 'source' - destination_file = 'destination_file' - mock_config.dovetail_config = { - 'vnftest': { - 'vnftest_conf': [{ - 'src_file': source_file, - 'dest_file': destination_file}]}} - - self.container.set_vnftest_conf_file() - - mock_copy.assert_called_once_with( - source_file, destination_file) + self.patcher1.stop() @patch('dovetail.container.dt_cfg') @patch.object(Container, 'copy_file') @@ -88,22 +75,6 @@ class ContainerTesting(unittest.TestCase): mock_copy.assert_not_called() - def test_docker_copy_error(self): - expected = (1, 'src_path or dest_path is empty') - result = self.container.docker_copy(None, None) - - self.assertEqual(expected, result) - - @patch('dovetail.container.dt_utils') - def test_docker_copy(self, mock_utils): - expected = (0, 'success') - mock_utils.exec_cmd.return_value = expected - result = self.container.docker_copy('source', 'dest') - - mock_utils.exec_cmd.assert_called_once_with( - 'docker cp source None:dest', self.logger) - self.assertEqual(expected, result) - def test_copy_file_error(self): expected = (1, 'src_path or dest_path is empty') result = self.container.copy_file(None, None) @@ -126,59 +97,115 @@ class ContainerTesting(unittest.TestCase): self.assertEqual(expected, result) + @patch('dovetail.container.dt_cfg') @patch('dovetail.container.dt_utils') - def test_exec_cmd(self, mock_utils): + def test_exec_cmd(self, mock_utils, mock_config): expected = (0, 'success') + mock_utils.get_value_from_dict.return_value = 'shell' + mock_config.dovetail_config = {'bottlenecks': 'value'} + container_obj = Mock() + container_obj.exec_run.return_value = expected + self.container.container = container_obj + + result = self.container.exec_cmd('command') + + self.assertEqual(expected, result) + + @patch('dovetail.container.dt_cfg') + @patch('dovetail.container.dt_utils') + @patch('sys.exit') + def test_exec_cmd_exception(self, mock_exit, mock_utils, mock_config): + mock_utils.get_value_from_dict.return_value = 'shell' + mock_config.dovetail_config = {'bottlenecks': 'value'} + container_obj = Mock() + response_obj = Mock() + response_obj.status_code = 1 + container_obj.exec_run.side_effect = \ + docker.errors.APIError('error', response=response_obj) + self.container.container = container_obj + + expected = (1, 'error') + result = self.container.exec_cmd('command', exit_on_error=True) + + self.assertEqual(expected, result) + mock_exit.assert_called_once_with(1) + + @patch('dovetail.container.dt_cfg') + @patch('dovetail.container.dt_utils') + def test_exec_cmd_no_shell(self, mock_utils, mock_config): + expected = (1, 'shell is empty') mock_utils.exec_cmd.return_value = expected + mock_utils.get_value_from_dict.return_value = None + mock_config.dovetail_config = {'bottlenecks': 'value'} result = self.container.exec_cmd('command') - mock_utils.exec_cmd.assert_called_once_with( - 'sudo docker exec None /bin/bash -c "command"', self.logger, False) self.assertEqual(expected, result) @patch('dovetail.container.dt_cfg') @patch('dovetail.container.dt_utils') - @patch.object(Container, 'check_container_exist') + @patch.object(Container, 'get_container') def test_clean(self, mock_check, mock_utils, mock_config): container_name = 'container' mock_config.dovetail_config = {'bottlenecks': 'value'} mock_utils.get_value_from_dict.return_value = [container_name] - mock_check.return_value = True + self.container.container = Mock() + mock_check.return_value = Mock() self.container.clean() mock_utils.get_value_from_dict.assert_called_once_with( 'extra_container', 'value') mock_check.assert_called_once_with(container_name) - mock_utils.exec_cmd.assert_has_calls([ - call('sudo docker rm -f None', self.logger), - call('sudo docker rm -f container', self.logger)]) + @patch('dovetail.container.dt_cfg') @patch('dovetail.container.dt_utils') - def test_check_container_exist_true(self, mock_utils): + @patch.object(Container, 'get_container') + def test_clean_extra_error(self, mock_check, mock_utils, mock_config): container_name = 'container' - cmd = ('sudo docker ps -aq -f name={}'.format(container_name)) - mock_utils.exec_cmd.return_value = (0, 'msg') + mock_config.dovetail_config = {'bottlenecks': 'value'} + mock_utils.get_value_from_dict.return_value = [container_name] + container_obj = Mock() + container_obj.remove.side_effect = docker.errors.APIError('error') + self.container.container = Mock() + mock_check.return_value = container_obj - result = self.container.check_container_exist(container_name) + self.container.clean() - mock_utils.exec_cmd.assert_called_once_with(cmd, self.logger) - self.assertEquals(True, result) + mock_utils.get_value_from_dict.assert_called_once_with( + 'extra_container', 'value') + mock_check.assert_called_once_with(container_name) + @patch('dovetail.container.dt_cfg') @patch('dovetail.container.dt_utils') - def test_check_container_exist_false(self, mock_utils): + def test_clean_no_extra_container(self, mock_utils, mock_config): + mock_utils.get_value_from_dict.return_value = None + container_obj = Mock() + container_obj.remove.side_effect = docker.errors.APIError('error') + self.container.container = container_obj + self.container.clean() + mock_utils.get_value_from_dict.assert_called_once() + + def test_get_container_exist_true(self): + container_name = 'container' + expected = Mock() + self.client.containers.get.return_value = expected + + result = self.container.get_container(container_name) + + self.assertEqual(expected, result) + + def test_get_container_none(self): container_name = 'container' - cmd = ('sudo docker ps -aq -f name={}'.format(container_name)) - mock_utils.exec_cmd.return_value = (1, 'msg') + self.client.containers.get.side_effect = \ + docker.errors.APIError('error') - result = self.container.check_container_exist(container_name) + result = self.container.get_container(container_name) - mock_utils.exec_cmd.assert_called_once_with(cmd, self.logger) - self.assertEquals(False, result) + self.assertEqual(None, result) def test_pull_image_none(self): result = self.container.pull_image(None) - self.assertEquals(None, result) + self.assertEqual(None, result) @patch.object(Container, 'pull_image_only') @patch.object(Container, 'get_image_id') @@ -190,7 +217,7 @@ class ContainerTesting(unittest.TestCase): mock_get.assert_called_once_with(docker_image) mock_pull.assert_called_once_with(docker_image) - self.assertEquals(None, result) + self.assertEqual(None, result) @patch.object(Container, 'pull_image_only') @patch.object(Container, 'get_image_id') @@ -206,7 +233,7 @@ class ContainerTesting(unittest.TestCase): call(docker_image), call(docker_image)]) self.logger.error.assert_called_once_with( 'Failed to get the id of image {}.'.format(docker_image)) - self.assertEquals(None, result) + self.assertEqual(None, result) @patch.object(Container, 'pull_image_only') @patch.object(Container, 'get_image_id') @@ -220,7 +247,7 @@ class ContainerTesting(unittest.TestCase): mock_pull.assert_called_once_with(docker_image) mock_get.assert_has_calls([ call(docker_image), call(docker_image)]) - self.assertEquals(docker_image, result) + self.assertEqual(docker_image, result) @patch.object(Container, 'pull_image_only') @patch.object(Container, 'get_image_id') @@ -236,7 +263,7 @@ class ContainerTesting(unittest.TestCase): call(docker_image), call(docker_image)]) self.logger.debug.assert_called_once_with( 'Image {} has no changes, no need to remove.'.format(docker_image)) - self.assertEquals(docker_image, result) + self.assertEqual(docker_image, result) @patch.object(Container, 'remove_image') @patch.object(Container, 'pull_image_only') @@ -253,101 +280,81 @@ class ContainerTesting(unittest.TestCase): mock_get.assert_has_calls([ call(docker_image), call(docker_image)]) mock_remove.assert_called_once_with(old_obj) - self.assertEquals(docker_image, result) + self.assertEqual(docker_image, result) - @patch('dovetail.container.dt_utils') - def test_pull_image_only(self, mock_utils): + def test_pull_image_only(self): docker_image = 'image' - mock_utils.exec_cmd.return_value = (0, 'msg') result = self.container.pull_image_only(docker_image) - cmd = 'sudo docker pull %s' % (docker_image) - mock_utils.exec_cmd.assert_called_once_with(cmd, self.logger) self.logger.debug.assert_called_once_with( 'Success to pull docker image {}!'.format(docker_image)) - self.assertEquals(True, result) + self.assertEqual(True, result) - @patch('dovetail.container.dt_utils') - def test_pull_image_only_error(self, mock_utils): + def test_pull_image_only_error(self): docker_image = 'image' - mock_utils.exec_cmd.return_value = (1, 'error') + self.client.images.pull.side_effect = docker.errors.APIError('error') result = self.container.pull_image_only(docker_image) - cmd = 'sudo docker pull %s' % (docker_image) - mock_utils.exec_cmd.assert_called_once_with(cmd, self.logger) self.logger.error.assert_called_once_with( 'Failed to pull docker image {}!'.format(docker_image)) - self.assertEquals(False, result) + self.assertEqual(False, result) - @patch('dovetail.container.dt_utils') - def test_remove_image(self, mock_utils): + def test_remove_image(self): image_id = 'image_id' - mock_utils.exec_cmd.side_effect = [(1, 'error'), (0, 'msg')] + self.client.containers.list.side_effect = \ + docker.errors.APIError('error') result = self.container.remove_image(image_id) - mock_utils.exec_cmd.assert_has_calls([ - call("sudo docker ps -aq -f 'ancestor=%s'" % (image_id), - self.logger), - call('sudo docker rmi %s' % (image_id), self.logger)]) self.logger.debug.assert_has_calls([ call('Remove image {}.'.format(image_id)), call('Remove image {} successfully.'.format(image_id))]) - self.assertEquals(True, result) + self.assertEqual(True, result) - @patch('dovetail.container.dt_utils') - def test_remove_image_ancestors(self, mock_utils): + def test_remove_image_ancestors(self): image_id = 'image_id' - mock_utils.exec_cmd.return_value = (0, 'msg') + self.client.containers.list.return_value = ['cont_a'] result = self.container.remove_image(image_id) - cmd = "sudo docker ps -aq -f 'ancestor=%s'" % (image_id) - mock_utils.exec_cmd.assert_called_once_with(cmd, self.logger) self.logger.debug.assert_called_once_with( 'Image {} has containers, skip.'.format(image_id)) - self.assertEquals(True, result) + self.assertEqual(True, result) - @patch('dovetail.container.dt_utils') - def test_remove_image_error(self, mock_utils): + def test_remove_image_error(self): image_id = 'image_id' - mock_utils.exec_cmd.return_value = (1, 'error') + self.client.containers.list.return_value = [] + self.client.images.remove.side_effect = \ + docker.errors.ImageNotFound('error') result = self.container.remove_image(image_id) - mock_utils.exec_cmd.assert_has_calls([ - call("sudo docker ps -aq -f 'ancestor=%s'" % (image_id), - self.logger), - call('sudo docker rmi %s' % (image_id), self.logger)]) self.logger.debug.assert_called_once_with( 'Remove image {}.'.format(image_id)) self.logger.error.assert_called_once_with( 'Failed to remove image {}.'.format(image_id)) - self.assertEquals(False, result) + self.assertEqual(False, result) - @patch('dovetail.container.dt_utils') - def test_get_image_id(self, mock_utils): + def test_get_image_id(self): image_name = 'image_id' - mock_utils.exec_cmd.return_value = (0, image_name) + mock_img = Mock() + mock_img.id = image_name + self.client.images.get.return_value = mock_img result = self.container.get_image_id(image_name) - cmd = 'sudo docker images -q %s' % (image_name) - mock_utils.exec_cmd.assert_called_once_with(cmd, self.logger) - self.assertEquals(image_name, result) + self.assertEqual(image_name, result) - @patch('dovetail.container.dt_utils') - def test_get_image_id_error(self, mock_utils): + def test_get_image_id_error(self): image_name = 'image_id' - mock_utils.exec_cmd.return_value = (1, 'error') + self.client.images.get.side_effect = \ + docker.errors.ImageNotFound('error') result = self.container.get_image_id(image_name) - cmd = 'sudo docker images -q %s' % (image_name) - mock_utils.exec_cmd.assert_called_once_with(cmd, self.logger) - self.assertEquals(None, result) + self.assertEqual(None, result) @patch('dovetail.container.dt_utils') def test_get_config(self, mock_utils): @@ -357,7 +364,7 @@ class ContainerTesting(unittest.TestCase): result = self.container._get_config('a', 'b', 'c') mock_utils.get_value_from_dict.assert_called_once_with('a', 'c') - self.assertEquals(expected, result) + self.assertEqual(expected, result) @patch('dovetail.container.dt_utils') def test_get_config_none(self, mock_utils): @@ -369,7 +376,7 @@ class ContainerTesting(unittest.TestCase): call('a', 'c'), call('a', 'b')]) self.logger.error.assert_called_once_with( "Couldn't find key {}.".format('a')) - self.assertEquals(None, result) + self.assertEqual(None, result) @patch('dovetail.container.dt_cfg') @patch.object(Container, '_get_config') @@ -383,7 +390,7 @@ class ContainerTesting(unittest.TestCase): mock_get_conf.assert_has_calls([ call('image_name', 'value', {'type': 'bottlenecks'}), call('docker_tag', 'value', {'type': 'bottlenecks'})]) - self.assertEquals(expected, result) + self.assertEqual(expected, result) @patch('dovetail.container.dt_logger') def test_create_log(self, mock_logger): @@ -393,54 +400,7 @@ class ContainerTesting(unittest.TestCase): self.container.create_log() - self.assertEquals(self.logger, self.container.logger) - - @patch('dovetail.container.dt_cfg') - @patch('dovetail.container.os.path') - def test_set_vnftest_config_no_file(self, mock_path, mock_config): - v_one = 'v_one' - v_two = 'v_two' - v_three = 'v_three' - v_four = 'v_four' - v_five = 'v_five' - mock_path.join.return_value = '/'.join([v_two, v_three]) - mock_path.isfile.return_value = False - mock_config.dovetail_config = { - 'result_dir': v_one, 'config_dir': v_two, - 'pri_key': v_three, 'vnftest': { - 'result': {'log': v_four, 'key_path': v_five}}} - - expected = '-v {}:{} '.format(v_one, v_four) - result = self.container.set_vnftest_config() - - mock_path.join.assert_called_once_with(v_two, v_three) - mock_path.isfile.assert_called_once_with('/'.join([v_two, v_three])) - self.logger.debug.assert_called_once_with( - 'Key file {} is not found'.format('/'.join([v_two, v_three]))) - self.assertEquals(expected, result) - - @patch('dovetail.container.dt_cfg') - @patch('dovetail.container.os.path') - def test_set_vnftest_config(self, mock_path, mock_config): - v_one = 'v_one' - v_two = 'v_two' - v_three = 'v_three' - v_four = 'v_four' - v_five = 'v_five' - mock_path.join.return_value = '/'.join([v_two, v_three]) - mock_path.isfile.return_value = True - mock_config.dovetail_config = { - 'result_dir': v_one, 'config_dir': v_two, - 'pri_key': v_three, 'vnftest': { - 'result': {'log': v_four, 'key_path': v_five}}} - - expected = '-v {}:{} -v {}/{}:{} '.format(v_one, v_four, v_two, - v_three, v_five) - result = self.container.set_vnftest_config() - - mock_path.join.assert_called_once_with(v_two, v_three) - mock_path.isfile.assert_called_once_with('/'.join([v_two, v_three])) - self.assertEquals(expected, result) + self.assertEqual(self.logger, self.container.logger) @patch('dovetail.container.dt_utils') @patch('dovetail.container.dt_cfg') @@ -448,109 +408,82 @@ class ContainerTesting(unittest.TestCase): docker_image = 'docker_image' container_id = 'container_id' mock_utils.get_value_from_dict.side_effect = [ - 'opts', 'envs', ['volume_one', 'volume_two']] + {'key': 'value'}, 'shell', 'envs', ['volume_one', 'volume_two']] + mock_utils.get_mount_list.side_effect = [['mount', 'list'], 'success'] mock_utils.get_hosts_info.return_value = 'host_info' - mock_utils.exec_cmd.return_value = (0, container_id) + container_obj = Mock() + container_obj.id = container_id + self.client.containers.run.return_value = container_obj project_config = {} mock_config.dovetail_config = {'bottlenecks': project_config} expected = container_id - result = self.container.create(docker_image) + result, msg = self.container.create(docker_image) mock_utils.get_value_from_dict.assert_has_calls([ call('opts', project_config), + call('shell', project_config), call('envs', project_config), call('volumes', project_config)]) mock_utils.get_hosts_info.assert_called_once_with(self.logger) - mock_utils.exec_cmd.assert_called_once_with( - 'sudo docker run opts envs volume_one volume_two host_info ' - 'docker_image /bin/bash', self.logger) - self.assertEquals(expected, result) + self.assertEqual(expected, result) + self.assertEqual('Successfully to create container.', msg) @patch('dovetail.container.dt_utils') @patch('dovetail.container.dt_cfg') - @patch('dovetail.container.os.getenv') - def test_create_error(self, mock_getenv, mock_config, mock_utils): + def test_create_no_shell(self, mock_config, mock_utils): docker_image = 'docker_image' - mock_utils.get_value_from_dict.side_effect = [ - 'opts', 'envs', ['volume_one']] - mock_getenv.side_effect = ['True', 'dovetail_home', None, 'True'] + mock_config.dovetail_config = {'bottlenecks': 'value'} + mock_utils.get_value_from_dict.side_effect = ['opts', None] mock_utils.get_hosts_info.return_value = 'host_info' - mock_utils.check_https_enabled.return_value = True - mock_utils.exec_cmd.return_value = (1, 'error') - project_config = {} - mock_config.dovetail_config = {'bottlenecks': project_config} - result = self.container.create(docker_image) + + result, msg = self.container.create(docker_image) mock_utils.get_value_from_dict.assert_has_calls([ - call('opts', project_config), - call('envs', project_config), - call('volumes', project_config)]) - mock_utils.get_hosts_info.assert_called_once_with(self.logger) - mock_utils.exec_cmd.assert_called_once_with( - 'sudo docker run opts envs volume_one host_info ' - 'docker_image /bin/bash', self.logger) - self.assertEquals(None, result) + call('opts', 'value'), + call('shell', 'value')]) + self.assertEqual(None, result) + self.assertEqual("Lacking of key word 'shell' in config file.", msg) @patch('dovetail.container.dt_utils') @patch('dovetail.container.dt_cfg') - @patch('dovetail.container.os.getenv') - @patch.object(Container, 'set_vnftest_config') - @patch.object(Container, 'set_vnftest_conf_file') - def test_create_vnftest(self, mock_setvnffile, mock_setvnfconf, - mock_getenv, mock_config, mock_utils): + def test_create_mounts_none(self, mock_config, mock_utils): docker_image = 'docker_image' - container_id = 'container_id' + project_config = {} + mock_config.dovetail_config = {'bottlenecks': project_config} mock_utils.get_value_from_dict.side_effect = [ - 'opts', 'envs', ['volume_one']] - mock_getenv.side_effect = ['False', 'dovetail_home', 'cacert', 'True'] - mock_setvnfconf.return_value = 'vnftest_config' + {'key': 'value'}, 'shell', ['envs'], ['volume_one']] + mock_utils.get_mount_list.side_effect = [[None, 'error']] mock_utils.get_hosts_info.return_value = 'host_info' - mock_utils.exec_cmd.return_value = (0, container_id) - project_config = {} - mock_config.dovetail_config = {'vnftest': project_config} - expected = container_id - self.container.valid_type = 'vnftest' - result = self.container.create(docker_image) - self.container.valid_type = 'bottlenecks' + result, msg = self.container.create(docker_image) mock_utils.get_value_from_dict.assert_has_calls([ - call('opts', project_config), - call('envs', project_config), - call('volumes', project_config)]) - mock_utils.get_hosts_info.assert_called_once_with(self.logger) - mock_setvnfconf.assert_called_once_with() - mock_setvnffile.assert_called_once_with(container_id) - mock_utils.exec_cmd.assert_called_once_with( - 'sudo docker run opts envs volume_one vnftest_config host_info ' - 'docker_image /bin/bash', - self.logger) - self.assertEquals(expected, result) + call('opts', project_config), call('shell', project_config), + call('envs', project_config), call('volumes', project_config)]) + self.assertEqual(None, result) + self.assertEqual('error', msg) @patch('dovetail.container.dt_utils') @patch('dovetail.container.dt_cfg') - @patch('dovetail.container.os.getenv') - @patch.object(Container, 'set_vnftest_config') - def test_create_vnftest_error(self, mock_setvnfconf, - mock_getenv, mock_config, mock_utils): + def test_create_error(self, mock_config, mock_utils): docker_image = 'docker_image' mock_utils.get_value_from_dict.side_effect = [ - 'opts', 'envs', ['volume_one']] - mock_getenv.return_value = 'True' - mock_setvnfconf.return_value = None - mock_config.dovetail_config = { - 'vnftest': 'value', - 'build_tag': 'v_one'} - - self.container.valid_type = 'vnftest' - result = self.container.create(docker_image) - self.container.valid_type = 'bottlenecks' + {'key': 'value'}, 'shell', ['envs'], ['volume_one']] + mock_utils.get_mount_list.side_effect = [['mount', 'list'], 'success'] + mock_utils.get_hosts_info.return_value = 'host_info' + mock_utils.check_https_enabled.return_value = True + self.client.containers.run.side_effect = \ + docker.errors.ImageNotFound('error') + project_config = {} + mock_config.dovetail_config = {'bottlenecks': project_config} + result, msg = self.container.create(docker_image) mock_utils.get_value_from_dict.assert_has_calls([ - call('opts', 'value'), - call('envs', 'value'), - call('volumes', 'value')]) + call('opts', project_config), + call('shell', project_config), + call('envs', project_config), + call('volumes', project_config)]) mock_utils.get_hosts_info.assert_called_once_with(self.logger) - mock_setvnfconf.assert_called_once_with() - self.assertEquals(None, result) + self.assertEqual(None, result) + self.assertEqual('error', str(docker.errors.ImageNotFound('error'))) diff --git a/dovetail/tests/unit/test_parser.py b/dovetail/tests/unit/test_parser.py index acfd25cf..4f164772 100644 --- a/dovetail/tests/unit/test_parser.py +++ b/dovetail/tests/unit/test_parser.py @@ -39,28 +39,28 @@ class TestParser(unittest.TestCase): def test_parser_cmd(self, mock_logger): """Test whether the command is correctly parsed.""" - mock_cmd = "python /functest/ci/run_tests.py "\ + mock_cmd = "python3 /functest/ci/run_tests.py "\ "-t {{validate_testcase}} -r" with open(os.path.join(self.test_path, 'test_testcase.yaml')) as f: mock_testcase_yaml = yaml.safe_load(f) MockTestcase = type('Testcase', (object,), {}) mock_testcase = MockTestcase() - mock_testcase.testcase = mock_testcase_yaml.values()[0] + mock_testcase.testcase = list(mock_testcase_yaml.values())[0] output = parser.Parser.parse_cmd(mock_cmd, mock_testcase) - expected_output = ("python /functest/ci/run_tests.py -t " + expected_output = ("python3 /functest/ci/run_tests.py -t " "tempest_smoke_serial -r") self.assertEqual(expected_output, output) def test_parser_cmd_fail(self, mock_logger): """Test whether the command is correctly parsed.""" - mock_cmd = "python /functest/ci/run_tests.py "\ + mock_cmd = "python3 /functest/ci/run_tests.py "\ "-t {{validate_testcase}} -r" mock_testcase_yaml = {} MockTestcase = type('Testcase', (object,), {}) mock_testcase = MockTestcase() mock_testcase.testcase = mock_testcase_yaml.values() output = parser.Parser.parse_cmd(mock_cmd, mock_testcase) - expected_output = ("python /functest/ci/run_tests.py -t " + expected_output = ("python3 /functest/ci/run_tests.py -t " "None -r") self.assertEqual(expected_output, output) diff --git a/dovetail/tests/unit/test_report.py b/dovetail/tests/unit/test_report.py index fa5a02e0..41d70d2f 100644 --- a/dovetail/tests/unit/test_report.py +++ b/dovetail/tests/unit/test_report.py @@ -8,6 +8,7 @@ # http://www.apache.org/licenses/LICENSE-2.0 ## +import json import os import unittest import yaml @@ -33,16 +34,19 @@ class ReportTesting(unittest.TestCase): dt_report.FunctestK8sCrawler.logger = None dt_report.YardstickCrawler.logger = None dt_report.BottlenecksCrawler.logger = None - dt_report.VnftestCrawler.logger = None + dt_report.OnapVtpCrawler.logger = None + dt_report.OnapVvpCrawler.logger = None dt_report.FunctestChecker.logger = None dt_report.FunctestK8sChecker.logger = None dt_report.YardstickChecker.logger = None dt_report.BottlenecksChecker.logger = None - dt_report.VnftestChecker.logger = None + dt_report.OnapVtpChecker.logger = None + dt_report.OnapVvpChecker.logger = None dt_report.Report.logger = None dt_report.Report.results = { 'functest': {}, 'yardstick': {}, 'functest-k8s': {}, - 'bottlenecks': {}, 'shell': {}, 'vnftest': {}} + 'bottlenecks': {}, 'shell': {}, 'onap-vtp': {}, + 'onap-vvp': {}} def _produce_report_initial_text(self, report_data): report_txt = '' @@ -62,7 +66,7 @@ class ReportTesting(unittest.TestCase): dt_report.Report.create_log() - self.assertEquals(getlogger_obj, dt_report.Report.logger) + self.assertEqual(getlogger_obj, dt_report.Report.logger) @patch('dovetail.report.os.path') @patch('dovetail.report.dt_cfg') @@ -78,7 +82,7 @@ class ReportTesting(unittest.TestCase): inner_testcase_obj = Mock() testcase_obj.testcase = inner_testcase_obj mock_config.dovetail_config = {'result_dir': 'result_dir'} - mock_utils.get_value_from_dict.return_value = 'check_results_file' + mock_utils.get_value_from_dict.return_value = ['check_results_file'] mock_path.join.return_value = 'results_file' mock_path.isfile.return_value = True mock_get.return_value = 'result' @@ -86,15 +90,15 @@ class ReportTesting(unittest.TestCase): result = report.check_tc_result(testcase_obj) mock_utils.get_value_from_dict.assert_called_once_with( - 'report.check_results_file', inner_testcase_obj) + 'report.check_results_files', inner_testcase_obj) mock_path.join.assert_called_once_with( 'result_dir', 'check_results_file') mock_path.isfile.assert_called_once_with('results_file') logger_obj.info.assert_called_once_with( - 'Results have been stored with file results_file.') - mock_get.assert_called_once_with(testcase_obj, 'results_file') + 'Results have been stored with files: [\'results_file\'].') + mock_get.assert_called_once_with(testcase_obj, ['results_file']) mock_check.assert_called_once_with(testcase_obj, 'result') - self.assertEquals('result', result) + self.assertEqual('result', result) @patch('dovetail.report.os.path') @patch('dovetail.report.dt_cfg') @@ -110,21 +114,21 @@ class ReportTesting(unittest.TestCase): inner_testcase_obj = Mock() testcase_obj.testcase = inner_testcase_obj mock_config.dovetail_config = {'result_dir': 'result_dir'} - mock_utils.get_value_from_dict.return_value = 'check_results_file' + mock_utils.get_value_from_dict.return_value = ['check_results_file'] mock_path.join.return_value = 'results_file' mock_path.isfile.return_value = False result = report.check_tc_result(testcase_obj) mock_utils.get_value_from_dict.assert_called_once_with( - 'report.check_results_file', inner_testcase_obj) + 'report.check_results_files', inner_testcase_obj) mock_path.join.assert_called_once_with( 'result_dir', 'check_results_file') mock_path.isfile.assert_called_once_with('results_file') logger_obj.error.assert_called_once_with( 'Failed to store results with file results_file.') mock_check.assert_called_once_with(testcase_obj) - self.assertEquals(None, result) + self.assertEqual(None, result) @patch('dovetail.report.os.path') @patch('dovetail.report.dt_cfg') @@ -146,12 +150,12 @@ class ReportTesting(unittest.TestCase): result = report.check_tc_result(testcase_obj) mock_utils.get_value_from_dict.assert_called_once_with( - 'report.check_results_file', inner_testcase_obj) + 'report.check_results_files', inner_testcase_obj) logger_obj.error.assert_called_once_with( - "Failed to get 'check_results_file' from config " + "Failed to get 'check_results_files' from config " "file of test case name") mock_check.assert_called_once_with(testcase_obj) - self.assertEquals(None, result) + self.assertEqual(None, result) @patch('dovetail.report.CheckerFactory') def test_check_result(self, mock_factory): @@ -166,25 +170,33 @@ class ReportTesting(unittest.TestCase): mock_factory.create.assert_called_once_with('type') checker_obj.check.assert_called_once_with(testcase_obj, None) + @patch('dovetail.report.os.getenv') + @patch.object(dt_report.Report, 'get_checksum') @patch('dovetail.report.Testcase') @patch('dovetail.report.datetime.datetime') @patch('dovetail.report.dt_cfg') - def test_generate_json(self, mock_config, mock_datetime, mock_testcase): + def test_generate_json(self, mock_config, mock_datetime, mock_testcase, + mock_checksum, mock_env): logger_obj = Mock() report = dt_report.Report() report.logger = logger_obj - testcase_list = ['t_a', 't_b'] + testcase_list = ['ta.tb.tc', 'td.te.tf'] duration = 42 mock_config.dovetail_config = { - 'build_tag': 'build_tag' + 'build_tag': 'build_tag', + 'version': '2018.09' } + mock_env.return_value = 'enabled' utc_obj = Mock() utc_obj.strftime.return_value = '2018-01-13 13:13:13 UTC' mock_datetime.utcnow.return_value = utc_obj testcase_obj = Mock() testcase_obj.passed.return_value = 'PASS' testcase_obj.objective.return_value = 'objective' + mock_checksum.return_value = 'da39a3ee5e6b4b0d3255bfef95601890afd80709' testcase_obj.is_mandatory = True + testcase_obj.portal_key_file.return_value = 'a/b.log' + testcase_obj.vnf_type.return_value = 'tosca' testcase_obj.sub_testcase.return_value = ['subt_a'] testcase_obj.sub_testcase_passed.return_value = 'PASS' mock_testcase.get.side_effect = [testcase_obj, None] @@ -193,137 +205,234 @@ class ReportTesting(unittest.TestCase): expected = { 'version': '2018.09', 'build_tag': 'build_tag', + 'vnf_type': 'tosca', + 'vnf_checksum': 'da39a3ee5e6b4b0d3255bfef95601890afd80709', 'test_date': '2018-01-13 13:13:13 UTC', 'duration': duration, + 'validation': 'enabled', 'testcases_list': [ { - 'name': 't_a', + 'name': 'ta.tb.tc', 'result': 'PASS', 'objective': 'objective', 'mandatory': True, + 'portal_key_file': 'a/b.log', 'sub_testcase': [{ 'name': 'subt_a', 'result': 'PASS' }] }, { - 'name': 't_b', + 'name': 'td.te.tf', 'result': 'Undefined', 'objective': '', 'mandatory': False, + 'portal_key_file': '', 'sub_testcase': [] } ] } - self.assertEquals(expected, result) + self.assertEqual(expected, result) + @patch('dovetail.report.os.getenv') + @patch('dovetail.report.Testcase') @patch('dovetail.report.datetime.datetime') @patch('dovetail.report.dt_cfg') - def test_generate_json_no_list(self, mock_config, mock_datetime): + def test_generate_json_noVNF(self, mock_config, mock_datetime, + mock_testcase, mock_env): logger_obj = Mock() report = dt_report.Report() report.logger = logger_obj + testcase_list = ['ta.tb.tc', 'td.te.tf'] duration = 42 mock_config.dovetail_config = { - 'build_tag': 'build_tag' + 'build_tag': 'build_tag', + 'version': '2018.09' } + mock_env.return_value = 'disabled' utc_obj = Mock() utc_obj.strftime.return_value = '2018-01-13 13:13:13 UTC' mock_datetime.utcnow.return_value = utc_obj + testcase_obj = Mock() + testcase_obj.passed.return_value = 'PASS' + testcase_obj.objective.return_value = 'objective' + testcase_obj.is_mandatory = True + testcase_obj.vnf_type.return_value = None + testcase_obj.portal_key_file.return_value = 'a/b.log' + testcase_obj.sub_testcase.return_value = ['subt_a'] + testcase_obj.sub_testcase_passed.return_value = 'PASS' + mock_testcase.get.side_effect = [testcase_obj, None] - result = report.generate_json([], duration) + result = report.generate_json(testcase_list, duration) expected = { 'version': '2018.09', 'build_tag': 'build_tag', 'test_date': '2018-01-13 13:13:13 UTC', 'duration': duration, - 'testcases_list': [] + 'validation': 'disabled', + 'testcases_list': [ + { + 'name': 'ta.tb.tc', + 'result': 'PASS', + 'objective': 'objective', + 'mandatory': True, + 'portal_key_file': 'a/b.log', + 'sub_testcase': [{ + 'name': 'subt_a', + 'result': 'PASS' + }] + }, + { + 'name': 'td.te.tf', + 'result': 'Undefined', + 'objective': '', + 'mandatory': False, + 'portal_key_file': '', + 'sub_testcase': [] + } + ] } - self.assertEquals(expected, result) + self.assertEqual(expected, result) + @patch('dovetail.report.os.getenv') + @patch('dovetail.report.Testcase') + @patch('dovetail.report.datetime.datetime') @patch('dovetail.report.dt_cfg') - @patch.object(dt_report.Report, 'generate_json') - @patch.object(dt_report.Report, 'save_json_results') - def test_generate(self, mock_save, mock_generate, mock_config): + def test_generate_json_noVNF_inTestCase(self, mock_config, mock_datetime, + mock_testcase, mock_env): logger_obj = Mock() report = dt_report.Report() report.logger = logger_obj - testcase_list = ['t_a', 't_b'] + testcase_list = ['ta.tb.tc', 'td.te.tf'] + duration = 42 mock_config.dovetail_config = { - 'testarea_supported': testcase_list + 'build_tag': 'build_tag', + 'version': '2018.09' } - duration = 42 - report_data = { - 'version': 'v2', - 'build_tag': '2.0.0', + mock_env.return_value = 'enabled' + utc_obj = Mock() + utc_obj.strftime.return_value = '2018-01-13 13:13:13 UTC' + mock_datetime.utcnow.return_value = utc_obj + testcase_obj = Mock() + testcase_obj.passed.return_value = 'PASS' + testcase_obj.objective.return_value = 'objective' + testcase_obj.is_mandatory = True + testcase_obj.portal_key_file.return_value = 'a/b.log' + testcase_obj.vnf_type.side_effect = Exception() + testcase_obj.sub_testcase.return_value = ['subt_a'] + testcase_obj.sub_testcase_passed.return_value = 'PASS' + mock_testcase.get.side_effect = [testcase_obj, None] + + result = report.generate_json(testcase_list, duration) + expected = { + 'version': '2018.09', + 'build_tag': 'build_tag', 'test_date': '2018-01-13 13:13:13 UTC', - 'duration': 42.42, + 'duration': duration, + 'validation': 'enabled', 'testcases_list': [ { - 'name': 't_a', + 'name': 'ta.tb.tc', 'result': 'PASS', + 'objective': 'objective', + 'mandatory': True, + 'portal_key_file': 'a/b.log', 'sub_testcase': [{ 'name': 'subt_a', 'result': 'PASS' }] }, { - 'name': 't_b', - 'result': 'SKIP' + 'name': 'td.te.tf', + 'result': 'Undefined', + 'objective': '', + 'mandatory': False, + 'portal_key_file': '', + 'sub_testcase': [] } ] } - mock_generate.return_value = report_data - result = report.generate(testcase_list, duration) - expected = self._produce_report_initial_text(report_data) - expected += 'Pass Rate: 100.00% (1/1)\n' - expected += '%-25s pass rate %.2f%%\n' % ('t_a:', 100) - expected += '-%-25s %s\n' % ('t_a', 'PASS') - expected += '\t%-110s %s\n' % ('subt_a', 'PASS') - expected += '%-25s all skipped\n' % 't_b' - expected += '-%-25s %s\n' % ('t_b', 'SKIP') + self.assertEqual(expected, result) - mock_generate.assert_called_once_with(testcase_list, duration) - mock_save.assert_called_once_with(report_data) - report.logger.info.assert_called_once_with(expected) - self.assertEquals(expected, result) + @patch('dovetail.report.datetime.datetime') + @patch('dovetail.report.dt_cfg') + @patch.object(dt_report.Report, 'get_checksum') + def test_generate_json_no_list(self, mock_checksum, mock_config, + mock_datetime): + logger_obj = Mock() + report = dt_report.Report() + report.logger = logger_obj + duration = 42 + mock_config.dovetail_config = { + 'build_tag': 'build_tag', + 'version': '2018.09', + 'vnf_type': 'tosca' + } + utc_obj = Mock() + utc_obj.strftime.return_value = '2018-01-13 13:13:13 UTC' + mock_datetime.utcnow.return_value = utc_obj + mock_checksum.return_value = 'da39a3ee5e6b4b0d3255bfef95601890afd80709' + + result = report.generate_json([], duration) + expected = { + 'version': '2018.09', + 'build_tag': 'build_tag', + 'vnf_type': 'tosca', + 'vnf_checksum': 'da39a3ee5e6b4b0d3255bfef95601890afd80709', + 'test_date': '2018-01-13 13:13:13 UTC', + 'duration': duration, + 'testcases_list': [] + } + + self.assertEqual(expected, result) @patch('dovetail.report.dt_cfg') @patch.object(dt_report.Report, 'generate_json') @patch.object(dt_report.Report, 'save_json_results') - def test_generate_error(self, mock_save, mock_generate, mock_config): + def test_generate(self, mock_save, mock_generate, mock_config): logger_obj = Mock() report = dt_report.Report() report.logger = logger_obj - mock_config.dovetail_config = { - 'testarea_supported': [] - } - testcase_list = ['t_a'] + testcase_list = ['ta.tb.tc', 'td.te.tf'] duration = 42 report_data = { 'version': 'v2', 'build_tag': '2.0.0', 'test_date': '2018-01-13 13:13:13 UTC', 'duration': 42.42, - 'testcases_list': [{ - 'name': 't_a', - 'result': 'PASS' - }] + 'testcases_list': [ + { + 'name': 'ta.tb.tc', + 'result': 'PASS', + 'sub_testcase': [{ + 'name': 'subt_a', + 'result': 'PASS' + }] + }, + { + 'name': 'td.te.tf', + 'result': 'SKIP' + } + ] } mock_generate.return_value = report_data result = report.generate(testcase_list, duration) - expected = None + expected = self._produce_report_initial_text(report_data) + expected += 'Pass Rate: 100.00% (1/1)\n' + expected += '%-25s pass rate %.2f%%\n' % ('tb:', 100) + expected += '-%-25s %s\n' % ('ta.tb.tc', 'PASS') + expected += '\t%-110s %s\n' % ('subt_a', 'PASS') + expected += '%-25s all skipped\n' % 'te' + expected += '-%-25s %s\n' % ('td.te.tf', 'SKIP') mock_generate.assert_called_once_with(testcase_list, duration) mock_save.assert_called_once_with(report_data) - report.logger.error.assert_called_once_with( - 'Test case {} not in supported testarea.' - .format(report_data['testcases_list'][0]['name'])) - self.assertEquals(expected, result) + report.logger.info.assert_called_once_with(expected) + self.assertEqual(expected, result) @patch('dovetail.report.dt_cfg') @patch.object(dt_report.Report, 'generate_json') @@ -332,9 +441,6 @@ class ReportTesting(unittest.TestCase): logger_obj = Mock() report = dt_report.Report() report.logger = logger_obj - mock_config.dovetail_config = { - 'testarea_supported': [] - } duration = 42 report_data = { 'version': 'v2', @@ -352,9 +458,9 @@ class ReportTesting(unittest.TestCase): mock_generate.assert_called_once_with([], duration) mock_save.assert_called_once_with(report_data) report.logger.info.assert_called_once_with(expected) - self.assertEquals(expected, result) + self.assertEqual(expected, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.report.json') @patch('dovetail.report.os.path') @patch('dovetail.report.dt_cfg') @@ -377,7 +483,7 @@ class ReportTesting(unittest.TestCase): mock_json.dumps.assert_called_once_with('results') file_obj.write.assert_called_once_with('results text\n') - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.report.json') @patch('dovetail.report.os.path') @patch('dovetail.report.dt_cfg') @@ -443,18 +549,18 @@ class ReportTesting(unittest.TestCase): mock_crawler.create.return_value = crawler_obj crawler_obj.crawl.return_value = 'result' - result = report.get_result(testcase_obj, 'check_results_file') + result = report.get_result(testcase_obj, 'check_results_files') testcase_obj.validate_testcase.assert_called_once_with() testcase_obj.validate_type.assert_called_once_with() mock_crawler.create.assert_called_once_with('functest') crawler_obj.crawl.assert_called_once_with( - testcase_obj, 'check_results_file') + testcase_obj, 'check_results_files') logger_obj.debug.assert_called_once_with( 'Test case: validate -> result acquired') - self.assertEquals({'validate': 'result'}, - dt_report.Report.results['functest']) - self.assertEquals('result', result) + self.assertEqual({'validate': 'result'}, + dt_report.Report.results['functest']) + self.assertEqual('result', result) @patch('dovetail.report.CrawlerFactory') def test_get_result_no_result(self, mock_crawler): @@ -469,17 +575,17 @@ class ReportTesting(unittest.TestCase): mock_crawler.create.return_value = crawler_obj crawler_obj.crawl.return_value = None - result = report.get_result(testcase_obj, 'check_results_file') + result = report.get_result(testcase_obj, 'check_results_files') testcase_obj.validate_testcase.assert_called_once_with() testcase_obj.validate_type.assert_called_once_with() mock_crawler.create.assert_called_once_with('functest') crawler_obj.crawl.assert_called_once_with( - testcase_obj, 'check_results_file') + testcase_obj, 'check_results_files') testcase_obj.increase_retry.assert_called_once_with() logger_obj.debug.assert_called_once_with( 'Test case: validate -> result acquired retry: retry') - self.assertEquals(None, result) + self.assertEqual(None, result) @patch('dovetail.report.CrawlerFactory') def test_get_result_no_crawler(self, mock_crawler): @@ -492,14 +598,14 @@ class ReportTesting(unittest.TestCase): testcase_obj.validate_type.return_value = 'functest' mock_crawler.create.return_value = None - result = report.get_result(testcase_obj, 'check_results_file') + result = report.get_result(testcase_obj, 'check_results_files') testcase_obj.validate_testcase.assert_called_once_with() testcase_obj.validate_type.assert_called_once_with() mock_crawler.create.assert_called_once_with('functest') logger_obj.error.assert_called_once_with( 'Crawler is None: name') - self.assertEquals(None, result) + self.assertEqual(None, result) @patch('dovetail.report.dt_logger') def test_functest_crawler_create_log(self, mock_logger): @@ -510,7 +616,7 @@ class ReportTesting(unittest.TestCase): dt_report.FunctestCrawler.create_log() - self.assertEquals(getlogger_obj, dt_report.FunctestCrawler.logger) + self.assertEqual(getlogger_obj, dt_report.FunctestCrawler.logger) @patch('dovetail.report.dt_cfg') @patch('dovetail.report.os.path') @@ -525,16 +631,38 @@ class ReportTesting(unittest.TestCase): testcase_obj.name.return_value = 'name' crawler = dt_report.FunctestCrawler() - result = crawler.crawl(testcase_obj, file_path) + result = crawler.crawl(testcase_obj, [file_path]) mock_path.exists.assert_called_once_with(file_path) testcase_obj.validate_testcase.assert_called_once_with() testcase_obj.name.assert_called_once_with() logger_obj.error.assert_called_once_with( 'Result file not found: {}'.format(file_path)) - self.assertEquals(None, result) + self.assertEqual(None, result) - @patch('__builtin__.open') + def test_functest_crawler_get_details_exception(self): + logger_obj = Mock() + dt_report.FunctestCrawler.logger = logger_obj + data = None + crawler = dt_report.FunctestCrawler() + + excepted = None + result = crawler.get_details(data) + logger_obj.exception.assert_called_once() + self.assertEqual(excepted, result) + + def test_functest_crawler_get_rally_details_exception(self): + logger_obj = Mock() + dt_report.FunctestCrawler.logger = logger_obj + data = None + crawler = dt_report.FunctestCrawler() + + excepted = None + result = crawler.get_rally_details(data) + logger_obj.exception.assert_called_once() + self.assertEqual(excepted, result) + + @patch('builtins.open') @patch('dovetail.report.json') @patch('dovetail.report.dt_cfg') @patch('dovetail.report.dt_utils') @@ -570,7 +698,7 @@ class ReportTesting(unittest.TestCase): mock_utils.get_duration.return_value = 'duration' crawler = dt_report.FunctestCrawler() - result = crawler.crawl(testcase_obj, file_path) + result = crawler.crawl(testcase_obj, [file_path]) expected = {'criteria': 'criteria', 'timestart': 'start_date', 'timestop': 'stop_date', 'duration': 'duration', 'details': { @@ -587,9 +715,69 @@ class ReportTesting(unittest.TestCase): testcase_obj.validate_testcase.assert_called_once_with() testcase_obj.sub_testcase.assert_called_once_with() testcase_obj.name.assert_called_once_with() - self.assertEquals(expected, result) + self.assertEqual(expected, result) + + @patch('builtins.open') + @patch('dovetail.report.json') + @patch('dovetail.report.dt_cfg') + @patch('dovetail.report.dt_utils') + @patch('dovetail.report.os.path') + def test_functest_rally_crawler_crawl(self, mock_path, mock_utils, + mock_config, mock_json, mock_open): + logger_obj = Mock() + mock_config.dovetail_config = {'build_tag': 'tag'} + dt_report.FunctestCrawler.logger = logger_obj + mock_path.exists.return_value = True + file_path = 'file_path' + testcase_obj = Mock() + testcase_obj.validate_testcase.return_value = 'rally_full' + testcase_obj.name.return_value = 'name' + testcase_obj.sub_testcase.return_value = ['subt_a', 'subt_b', 'subt_c'] + file_obj = Mock() + mock_open.return_value.__enter__.side_effect = [[file_obj], file_obj] + data_dict = { + 'case_name': 'rally_full', + 'build_tag': 'tag-name', + 'criteria': 'criteria', + 'start_date': 'start_date', + 'stop_date': 'stop_date', + 'details': { + 'modules': [ + { + 'details': { + 'success': ['subt_a'], + 'failures': ['subt_b', 'subt_c'] + }, + 'module': 'module' + } + ] + } + } + + mock_json.loads.return_value = data_dict + mock_utils.get_duration.return_value = 'duration' + + crawler = dt_report.FunctestCrawler() + result = crawler.crawl(testcase_obj, [file_path, file_path]) + expected = {'criteria': 'criteria', 'timestart': 'start_date', + 'timestop': 'stop_date', 'duration': 'duration', + 'details': { + 'tests': 3, 'failures': 2, + 'success': ['subt_a'], 'errors': ['subt_b', 'subt_c'], + 'skipped': []}} + + mock_path.exists.assert_called_once_with(file_path) + mock_open.assert_called_with(file_path, 'r') + mock_json.loads.assert_called_with(file_obj) + mock_utils.get_duration.assert_called_once_with( + 'start_date', 'stop_date', logger_obj) + testcase_obj.set_results.assert_called_with(expected) + testcase_obj.validate_testcase.assert_called_once_with() + testcase_obj.sub_testcase.assert_called_once_with() + testcase_obj.name.assert_called_once_with() + self.assertEqual(expected, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.report.json.loads') @patch('dovetail.report.dt_cfg') @patch('dovetail.report.dt_utils') @@ -612,7 +800,7 @@ class ReportTesting(unittest.TestCase): mock_utils.get_duration.return_value = 'duration' crawler = dt_report.FunctestCrawler() - result = crawler.crawl(testcase_obj, file_path) + result = crawler.crawl(testcase_obj, [file_path]) mock_path.exists.assert_called_once_with(file_path) mock_open.assert_called_once_with(file_path, 'r') @@ -622,7 +810,7 @@ class ReportTesting(unittest.TestCase): testcase_obj.name.assert_called_once_with() logger_obj.exception.assert_called_once_with( "Result data don't have key 'case_name'.") - self.assertEquals(None, result) + self.assertEqual(None, result) @patch('dovetail.report.dt_logger') def test_functestk8s_crawler_create_log(self, mock_logger): @@ -633,7 +821,7 @@ class ReportTesting(unittest.TestCase): dt_report.FunctestK8sCrawler.create_log() - self.assertEquals(getlogger_obj, dt_report.FunctestK8sCrawler.logger) + self.assertEqual(getlogger_obj, dt_report.FunctestK8sCrawler.logger) @patch('dovetail.report.FunctestK8sCrawler.crawl_from_file') @patch('dovetail.report.dt_cfg') @@ -648,11 +836,11 @@ class ReportTesting(unittest.TestCase): crawler = dt_report.FunctestK8sCrawler() - result = crawler.crawl(testcase, file_path) + result = crawler.crawl(testcase, [file_path]) dt_report.FunctestK8sCrawler.crawl_from_file.assert_called_once_with( 'testcase', 'file_path') - self.assertEquals(None, result) + self.assertEqual(None, result) @patch('dovetail.report.dt_logger') def test_yardstick_crawler_create_log(self, mock_logger): @@ -663,7 +851,7 @@ class ReportTesting(unittest.TestCase): dt_report.YardstickCrawler.create_log() - self.assertEquals(getlogger_obj, dt_report.YardstickCrawler.logger) + self.assertEqual(getlogger_obj, dt_report.YardstickCrawler.logger) @patch('dovetail.report.os.path') def test_yardstick_crawler_crawl_not_exists(self, mock_path): @@ -673,14 +861,14 @@ class ReportTesting(unittest.TestCase): file_path = 'file_path' crawler = dt_report.YardstickCrawler() - result = crawler.crawl(None, file_path) + result = crawler.crawl(None, [file_path]) mock_path.exists.assert_called_once_with(file_path) logger_obj.error.assert_called_once_with( 'Result file not found: {}'.format(file_path)) - self.assertEquals(None, result) + self.assertEqual(None, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.report.json.loads') @patch('dovetail.report.dt_utils') @patch('dovetail.report.os.path') @@ -710,7 +898,7 @@ class ReportTesting(unittest.TestCase): mock_utils.get_value_from_dict.return_value = 'PASS' crawler = dt_report.YardstickCrawler() - result = crawler.crawl(testcase_obj, file_path) + result = crawler.crawl(testcase_obj, [file_path]) expected = {'criteria': 'FAIL'} mock_path.exists.assert_called_once_with(file_path) @@ -720,9 +908,9 @@ class ReportTesting(unittest.TestCase): 'result.criteria', data_dict) testcase_obj.validate_testcase.assert_called_once_with() testcase_obj.set_results.assert_called_once_with(expected) - self.assertEquals(expected, result) + self.assertEqual(expected, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.report.json.loads') @patch('dovetail.report.dt_utils') @patch('dovetail.report.os.path') @@ -741,7 +929,7 @@ class ReportTesting(unittest.TestCase): mock_utils.get_value_from_dict.return_value = 'PASS' crawler = dt_report.YardstickCrawler() - result = crawler.crawl(testcase_obj, file_path) + result = crawler.crawl(testcase_obj, [file_path]) expected = {'criteria': 'PASS'} mock_path.exists.assert_called_once_with(file_path) @@ -753,7 +941,7 @@ class ReportTesting(unittest.TestCase): testcase_obj.set_results.assert_called_once_with(expected) logger_obj.exception.assert_called_once_with( "Pass flag not found 'result'") - self.assertEquals(expected, result) + self.assertEqual(expected, result) @patch('dovetail.report.dt_logger') def test_bottlenecks_crawler_create_log(self, mock_logger): @@ -764,7 +952,7 @@ class ReportTesting(unittest.TestCase): dt_report.BottlenecksCrawler.create_log() - self.assertEquals(getlogger_obj, dt_report.BottlenecksCrawler.logger) + self.assertEqual(getlogger_obj, dt_report.BottlenecksCrawler.logger) @patch('dovetail.report.os.path') def test_bottlenecks_crawler_crawl_not_exists(self, mock_path): @@ -774,14 +962,14 @@ class ReportTesting(unittest.TestCase): file_path = 'file_path' crawler = dt_report.BottlenecksCrawler() - result = crawler.crawl(None, file_path) + result = crawler.crawl(None, [file_path]) mock_path.exists.assert_called_once_with(file_path) logger_obj.error.assert_called_once_with( 'Result file not found: {}'.format(file_path)) - self.assertEquals(None, result) + self.assertEqual(None, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.report.json.loads') @patch('dovetail.report.os.path') def test_bottlenecks_crawler_crawl_pass(self, mock_path, mock_loads, @@ -800,16 +988,16 @@ class ReportTesting(unittest.TestCase): mock_loads.return_value = data_dict crawler = dt_report.BottlenecksCrawler() - result = crawler.crawl(testcase_obj, file_path) + result = crawler.crawl(testcase_obj, [file_path]) expected = {'criteria': 'PASS'} mock_path.exists.assert_called_once_with(file_path) mock_open.assert_called_once_with(file_path, 'r') mock_loads.assert_called_once_with(file_obj) testcase_obj.set_results.assert_called_once_with(expected) - self.assertEquals(expected, result) + self.assertEqual(expected, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.report.json.loads') @patch('dovetail.report.os.path') def test_bottlenecks_crawler_crawl_fail(self, mock_path, mock_loads, @@ -828,16 +1016,16 @@ class ReportTesting(unittest.TestCase): mock_loads.return_value = data_dict crawler = dt_report.BottlenecksCrawler() - result = crawler.crawl(testcase_obj, file_path) + result = crawler.crawl(testcase_obj, [file_path]) expected = {'criteria': 'FAIL'} mock_path.exists.assert_called_once_with(file_path) mock_open.assert_called_once_with(file_path, 'r') mock_loads.assert_called_once_with(file_obj) testcase_obj.set_results.assert_called_once_with(expected) - self.assertEquals(expected, result) + self.assertEqual(expected, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.report.json.loads') @patch('dovetail.report.os.path') def test_bottlenecks_crawler_crawl_key_error(self, mock_path, mock_loads, @@ -853,7 +1041,7 @@ class ReportTesting(unittest.TestCase): mock_loads.return_value = {} crawler = dt_report.BottlenecksCrawler() - result = crawler.crawl(testcase_obj, file_path) + result = crawler.crawl(testcase_obj, [file_path]) expected = {'criteria': 'FAIL'} mock_path.exists.assert_called_once_with(file_path) @@ -862,7 +1050,7 @@ class ReportTesting(unittest.TestCase): testcase_obj.set_results.assert_called_once_with(expected) logger_obj.exception.assert_called_once_with( "Pass flag not found 'data_body'") - self.assertEquals(expected, result) + self.assertEqual(expected, result) @patch('dovetail.report.os.path') def test_shell_crawler_crawl_not_exists(self, mock_path): @@ -870,12 +1058,12 @@ class ReportTesting(unittest.TestCase): file_path = 'file_path' crawler = dt_report.ShellCrawler() - result = crawler.crawl(None, file_path) + result = crawler.crawl(None, [file_path]) mock_path.exists.assert_called_once_with(file_path) - self.assertEquals(None, result) + self.assertEqual(None, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.report.os.path') def test_shell_crawler_crawl_exception(self, mock_path, mock_open): mock_path.exists.return_value = True @@ -883,13 +1071,13 @@ class ReportTesting(unittest.TestCase): mock_open.return_value.__enter__.return_value = Exception() crawler = dt_report.ShellCrawler() - result = crawler.crawl(None, file_path) + result = crawler.crawl(None, [file_path]) mock_path.exists.assert_called_once_with(file_path) mock_open.assert_called_once_with(file_path, 'r') - self.assertEquals(None, result) + self.assertEqual(None, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.report.json.load') @patch('dovetail.report.os.path') def test_shell_crawler_crawl(self, mock_path, mock_load, @@ -901,101 +1089,313 @@ class ReportTesting(unittest.TestCase): mock_load.return_value = 'result' crawler = dt_report.ShellCrawler() - result = crawler.crawl(None, file_path) + result = crawler.crawl(None, [file_path]) mock_path.exists.assert_called_once_with(file_path) mock_open.assert_called_once_with(file_path, 'r') mock_load.assert_called_once_with(file_obj) - self.assertEquals('result', result) + self.assertEqual('result', result) + + @patch('dovetail.report.dt_logger') + def test_onapvtp_crawler_create_log(self, mock_logger): + getlogger_obj = Mock() + logger_obj = Mock() + logger_obj.getLogger.return_value = getlogger_obj + mock_logger.Logger.return_value = logger_obj + + dt_report.OnapVtpCrawler.create_log() + + self.assertEqual(getlogger_obj, dt_report.OnapVtpCrawler.logger) @patch('dovetail.report.dt_logger') - def test_vnftest_crawler_create_log(self, mock_logger): + def test_onapvvp_crawler_create_log(self, mock_logger): getlogger_obj = Mock() logger_obj = Mock() logger_obj.getLogger.return_value = getlogger_obj mock_logger.Logger.return_value = logger_obj - dt_report.VnftestCrawler.create_log() + dt_report.OnapVvpCrawler.create_log() - self.assertEquals(getlogger_obj, dt_report.VnftestCrawler.logger) + self.assertEqual(getlogger_obj, dt_report.OnapVvpCrawler.logger) @patch('dovetail.report.os.path') - def test_vnftest_crawler_crawl_not_exists(self, mock_path): + def test_onapvtp_crawler_crawl_not_exists(self, mock_path): logger_obj = Mock() - dt_report.VnftestCrawler.logger = logger_obj + dt_report.OnapVtpCrawler.logger = logger_obj mock_path.exists.return_value = False file_path = 'file_path' - crawler = dt_report.VnftestCrawler() - result = crawler.crawl(None, file_path) + crawler = dt_report.OnapVtpCrawler() + result = crawler.crawl(None, [file_path]) mock_path.exists.assert_called_once_with(file_path) logger_obj.error.assert_called_once_with( 'Result file not found: {}'.format(file_path)) - self.assertEquals(None, result) + self.assertEqual(None, result) - @patch('__builtin__.open') + @patch('dovetail.report.os.path') + def test_onapvvp_crawler_crawl_not_exists(self, mock_path): + logger_obj = Mock() + dt_report.OnapVvpCrawler.logger = logger_obj + mock_path.exists.return_value = False + file_path = 'file_path' + + crawler = dt_report.OnapVvpCrawler() + result = crawler.crawl(None, [file_path]) + + mock_path.exists.assert_called_once_with(file_path) + logger_obj.error.assert_called_once_with( + 'Result file not found: {}'.format(file_path)) + self.assertEqual(None, result) + + @patch('builtins.open') + @patch('dovetail.report.os.path') + def test_onapvvp_crawler_crawl_pass(self, mock_path, + mock_open): + dt_report.OnapVvpCrawler.logger = Mock() + mock_path.exists.return_value = True + file_path = 'file_path' + testcase_obj = Mock() + file_obj = Mock() + file_obj.read.return_value = json.dumps({'outcome': 'PASS'}) + mock_open.return_value.__enter__.return_value = file_obj + + crawler = dt_report.OnapVvpCrawler() + result = crawler.crawl(testcase_obj, [file_path]) + expected = {'criteria': 'PASS'} + + mock_path.exists.assert_called_once_with(file_path) + mock_open.assert_called_once_with(file_path, 'r') + file_obj.read.assert_called_once_with() + testcase_obj.set_results.assert_called_once_with(expected) + self.assertEqual(expected, result) + + @patch('builtins.open') + @patch('dovetail.report.os.path') + def test_onapvvp_crawler_crawl_fail(self, mock_path, + mock_open): + dt_report.OnapVvpCrawler.logger = Mock() + mock_path.exists.return_value = True + file_path = 'file_path' + testcase_obj = Mock() + file_obj = Mock() + file_obj.read.return_value = json.dumps({'outcome': 'FAIL'}) + mock_open.return_value.__enter__.return_value = file_obj + + crawler = dt_report.OnapVvpCrawler() + result = crawler.crawl(testcase_obj, [file_path]) + expected = {'criteria': 'FAIL'} + + mock_path.exists.assert_called_once_with(file_path) + mock_open.assert_called_once_with(file_path, 'r') + file_obj.read.assert_called_once_with() + testcase_obj.set_results.assert_called_once_with(expected) + self.assertEqual(expected, result) + + @patch('builtins.open') + @patch('dovetail.report.os.path') + def test_onapvvp_crawler_crawl_value_exception(self, mock_path, + mock_open): + dt_report.OnapVvpCrawler.logger = Mock() + mock_path.exists.return_value = True + file_path = 'file_path' + testcase_obj = Mock() + file_obj = Mock() + file_obj.read.return_value = 'error' + mock_open.return_value.__enter__.return_value = file_obj + + crawler = dt_report.OnapVvpCrawler() + result = crawler.crawl(testcase_obj, [file_path]) + expected = {'criteria': 'FAIL'} + + mock_path.exists.assert_called_once_with(file_path) + mock_open.assert_called_once_with(file_path, 'r') + file_obj.read.assert_called_once_with() + dt_report.OnapVvpCrawler.logger.exception.assert_called_once_with( + 'Result file has invalid format') + testcase_obj.set_results.assert_called_once_with(expected) + self.assertEqual(expected, result) + + @patch('builtins.open') + @patch('dovetail.report.os.path') + def test_onapvvp_crawler_crawl_key_exception(self, mock_path, + mock_open): + dt_report.OnapVvpCrawler.logger = Mock() + mock_path.exists.return_value = True + file_path = 'file_path' + testcase_obj = Mock() + file_obj = Mock() + file_obj.read.return_value = json.dumps({'key': 'value'}) + mock_open.return_value.__enter__.return_value = file_obj + + crawler = dt_report.OnapVvpCrawler() + result = crawler.crawl(testcase_obj, [file_path]) + expected = {'criteria': 'FAIL'} + + mock_path.exists.assert_called_once_with(file_path) + mock_open.assert_called_once_with(file_path, 'r') + file_obj.read.assert_called_once_with() + dt_report.OnapVvpCrawler.logger.exception.assert_called_once_with( + "Outcome field not found 'outcome'") + testcase_obj.set_results.assert_called_once_with(expected) + self.assertEqual(expected, result) + + @patch('builtins.open') @patch('dovetail.report.json.loads') @patch('dovetail.report.os.path') - def test_vnftest_crawler_crawl(self, mock_path, mock_loads, - mock_open): - dt_report.VnftestCrawler.logger = Mock() + def test_onapvtp_crawler_crawl_pass(self, mock_path, mock_loads, + mock_open): + dt_report.OnapVtpCrawler.logger = Mock() mock_path.exists.return_value = True file_path = 'file_path' testcase_obj = Mock() file_obj = Mock() mock_open.return_value.__enter__.return_value = [file_obj] data_dict = { - 'result': { - 'criteria': 'PASS' - } + 'results': [ + {"property": "results", "value": "{value=SUCCESS}"}, + {"property": "build_tag", "value": "test-name"}, + {"property": "criteria", "value": "PASS"} + ] } mock_loads.return_value = data_dict - crawler = dt_report.VnftestCrawler() - result = crawler.crawl(testcase_obj, file_path) + crawler = dt_report.OnapVtpCrawler() + result = crawler.crawl(testcase_obj, [file_path]) expected = {'criteria': 'PASS'} mock_path.exists.assert_called_once_with(file_path) mock_open.assert_called_once_with(file_path, 'r') mock_loads.assert_called_once_with(file_obj) - self.assertEquals(expected, result) + testcase_obj.set_results.assert_called_once_with(expected) + self.assertEqual(expected, result) + + @patch('builtins.open') + @patch('dovetail.report.json.loads') + @patch('dovetail.report.os.path') + def test_onapvtp_crawler_crawl_fail(self, mock_path, mock_loads, + mock_open): + dt_report.OnapVtpCrawler.logger = Mock() + mock_path.exists.return_value = True + file_path = 'file_path' + testcase_obj = Mock() + file_obj = Mock() + mock_open.return_value.__enter__.return_value = [file_obj] + data_dict = { + 'results': [ + {"property": "results", "value": "{value=file doesn't exist}"}, + {"property": "build_tag", "value": "test-name"}, + {"property": "criteria", "value": "FAILED"} + ] + } + mock_loads.return_value = data_dict + + crawler = dt_report.OnapVtpCrawler() + result = crawler.crawl(testcase_obj, [file_path]) + expected = {'criteria': 'FAIL'} + + mock_path.exists.assert_called_once_with(file_path) + mock_open.assert_called_once_with(file_path, 'r') + mock_loads.assert_called_once_with(file_obj) + testcase_obj.set_results.assert_called_once_with(expected) + self.assertEqual(expected, result) + + @patch('builtins.open') + @patch('dovetail.report.json.loads') + @patch('dovetail.report.os.path') + def test_onapvtp_crawler_crawl_no_criteria(self, mock_path, mock_loads, + mock_open): + dt_report.OnapVtpCrawler.logger = Mock() + mock_path.exists.return_value = True + file_path = 'file_path' + testcase_obj = Mock() + file_obj = Mock() + mock_open.return_value.__enter__.return_value = [file_obj] + data_dict = { + 'results': [ + {"property": "results", "value": "{value=file doesn't exist}"}, + {"property": "build_tag", "value": "test-name"}, + {"property": "error_criteria", "value": "FAILED"} + ] + } + mock_loads.return_value = data_dict + + crawler = dt_report.OnapVtpCrawler() + result = crawler.crawl(testcase_obj, [file_path]) + expected = {'criteria': 'FAIL'} + + mock_path.exists.assert_called_once_with(file_path) + mock_open.assert_called_once_with(file_path, 'r') + mock_loads.assert_called_once_with(file_obj) + dt_report.OnapVtpCrawler.logger.error.assert_called_once_with( + 'There is no property criteria.') + testcase_obj.set_results.assert_called_once_with(expected) + self.assertEqual(expected, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.report.json.loads') @patch('dovetail.report.os.path') - def test_vnftest_crawler_crawl_key_error(self, mock_path, mock_loads, + def test_onapvtp_crawler_crawl_exception(self, mock_path, mock_loads, mock_open): - logger_obj = Mock() - dt_report.VnftestCrawler.logger = logger_obj + dt_report.OnapVtpCrawler.logger = Mock() mock_path.exists.return_value = True file_path = 'file_path' testcase_obj = Mock() file_obj = Mock() mock_open.return_value.__enter__.return_value = [file_obj] + data_dict = { + 'error_results': [ + {"property": "results", "value": "{value=file doesn't exist}"}, + {"property": "build_tag", "value": "test-name"}, + {"property": "error_criteria", "value": "FAILED"} + ] + } + mock_loads.return_value = data_dict - mock_loads.return_value = {} + crawler = dt_report.OnapVtpCrawler() + result = crawler.crawl(testcase_obj, [file_path]) + expected = {'criteria': 'FAIL'} - crawler = dt_report.VnftestCrawler() - result = crawler.crawl(testcase_obj, file_path) + mock_path.exists.assert_called_once_with(file_path) + mock_open.assert_called_once_with(file_path, 'r') + mock_loads.assert_called_once_with(file_obj) + dt_report.OnapVtpCrawler.logger.exception.assert_called_once_with( + "Pass flag not found 'results'") + testcase_obj.set_results.assert_called_once_with(expected) + self.assertEqual(expected, result) + + @patch('builtins.open') + @patch('dovetail.report.json.loads') + @patch('dovetail.report.os.path') + def test_onapvtp_crawler_crawl_value_error(self, mock_path, mock_loads, + mock_open): + dt_report.OnapVtpCrawler.logger = Mock() + mock_path.exists.return_value = True + file_path = 'file_path' + testcase_obj = Mock() + file_obj = Mock() + mock_open.return_value.__enter__.return_value = [file_obj] + mock_loads.side_effect = ValueError('No JSON object could be decoded') + + crawler = dt_report.OnapVtpCrawler() + result = crawler.crawl(testcase_obj, [file_path]) expected = {'criteria': 'FAIL'} mock_path.exists.assert_called_once_with(file_path) mock_open.assert_called_once_with(file_path, 'r') mock_loads.assert_called_once_with(file_obj) - logger_obj.exception.assert_called_once_with( - "Pass flag not found 'result'") - self.assertEquals(expected, result) + testcase_obj.set_results.assert_called_once_with(expected) + self.assertEqual(expected, result) def test_crawler_factory(self): result = dt_report.CrawlerFactory.create('shell') - self.assertEquals(dt_report.ShellCrawler, result.__class__) + self.assertEqual(dt_report.ShellCrawler, result.__class__) def test_crawler_factory_none(self): - self.assertEquals(None, dt_report.CrawlerFactory.create('other')) + self.assertEqual(None, dt_report.CrawlerFactory.create('other')) def test_result_checker(self): - self.assertEquals('PASS', dt_report.ResultChecker.check()) + self.assertEqual('PASS', dt_report.ResultChecker.check()) @patch('dovetail.report.dt_logger') def test_functest_checker_create_log(self, mock_logger): @@ -1006,26 +1406,40 @@ class ReportTesting(unittest.TestCase): dt_report.FunctestChecker.create_log() - self.assertEquals(getlogger_obj, dt_report.FunctestChecker.logger) + self.assertEqual(getlogger_obj, dt_report.FunctestChecker.logger) def test_functest_get_sub_testcase_no_result(self): - self.assertEquals( + self.assertEqual( False, dt_report.FunctestChecker.get_sub_testcase(None, None)) def test_functest_get_sub_testcase_simple_match(self): - self.assertEquals( + self.assertEqual( True, dt_report.FunctestChecker.get_sub_testcase('subt_a', ['subt_b', 'subt_a'])) def test_functest_get_sub_testcase_extended_match(self): - self.assertEquals( + self.assertEqual( True, dt_report.FunctestChecker.get_sub_testcase('subt_a', ['subt_b', 'subt_a+'])) + def test_functest_get_sub_testcase_class_match(self): + self.assertEqual( + True, + dt_report.FunctestChecker.get_sub_testcase('subclass_a.subt_a', + ['subclass_a', + 'subclass_b.subt_b'])) + + def test_functest_get_sub_testcase_class_no_match(self): + self.assertEqual( + False, + dt_report.FunctestChecker.get_sub_testcase('subclass_a.subt_a', + ['subclass_a.subt_a_a', + 'subclass_b.subt_b'])) + def test_functest_get_sub_no_match(self): - self.assertEquals( + self.assertEqual( False, dt_report.FunctestChecker.get_sub_testcase('subt_a', ['subt_b'])) @@ -1071,16 +1485,6 @@ class ReportTesting(unittest.TestCase): checker.check(testcase_obj, db_result) testcase_obj.sub_testcase.assert_called_once_with() - logger_obj.debug.assert_has_calls([ - call('Check sub_testcase: subt_a'), - call('Check sub_testcase: subt_b'), - call('Check sub_testcase: subt_c'), - call('Check sub_testcase: subt_d')]) - testcase_obj.sub_testcase_passed.assert_has_calls([ - call('subt_a', 'PASS'), - call('subt_b', 'SKIP'), - call('subt_c', 'FAIL'), - call('subt_d', 'FAIL')]) testcase_obj.passed.assert_has_calls([call('PASS'), call('FAIL')]) @patch('dovetail.report.dt_logger') @@ -1092,7 +1496,7 @@ class ReportTesting(unittest.TestCase): dt_report.FunctestK8sChecker.create_log() - self.assertEquals(getlogger_obj, dt_report.FunctestK8sChecker.logger) + self.assertEqual(getlogger_obj, dt_report.FunctestK8sChecker.logger) @patch('dovetail.report.dt_logger') def test_yardstick_checker_create_log(self, mock_logger): @@ -1103,7 +1507,7 @@ class ReportTesting(unittest.TestCase): dt_report.YardstickChecker.create_log() - self.assertEquals(getlogger_obj, dt_report.YardstickChecker.logger) + self.assertEqual(getlogger_obj, dt_report.YardstickChecker.logger) def test_yardstick_check_result(self): testcase_obj = Mock() @@ -1130,7 +1534,7 @@ class ReportTesting(unittest.TestCase): dt_report.BottlenecksChecker.create_log() - self.assertEquals(getlogger_obj, dt_report.BottlenecksChecker.logger) + self.assertEqual(getlogger_obj, dt_report.BottlenecksChecker.logger) def test_bottlenecks_check_result(self): testcase_obj = Mock() @@ -1164,36 +1568,104 @@ class ReportTesting(unittest.TestCase): testcase_obj.passed.assert_called_once_with(False) + def test_checker_factory(self): + result = dt_report.CheckerFactory.create('shell') + self.assertEqual(dt_report.ShellChecker, result.__class__) + + def test_checker_factory_none(self): + self.assertEqual(None, dt_report.CheckerFactory.create('other')) + @patch('dovetail.report.dt_logger') - def test_vnftest_checker_create_log(self, mock_logger): + def test_onapvtp_checker_create_log(self, mock_logger): getlogger_obj = Mock() logger_obj = Mock() logger_obj.getLogger.return_value = getlogger_obj mock_logger.Logger.return_value = logger_obj - dt_report.VnftestChecker.create_log() + dt_report.OnapVtpChecker.create_log() + + self.assertEqual(getlogger_obj, dt_report.OnapVtpChecker.logger) + + def test_onapvtp_check_result_none(self): + testcase_obj = Mock() + result = {} + + dt_report.OnapVtpChecker.check(testcase_obj, result) - self.assertEquals(getlogger_obj, dt_report.VnftestChecker.logger) + testcase_obj.passed.assert_called_once_with('FAIL') - def test_vnftest_check_result(self): + def test_onapvtp_check_result(self): testcase_obj = Mock() result = {'criteria': 'PASS'} - dt_report.VnftestChecker.check(testcase_obj, result) + dt_report.OnapVtpChecker.check(testcase_obj, result) testcase_obj.passed.assert_called_once_with('PASS') - def test_vnftest_check_result_none(self): + @patch('dovetail.report.dt_logger') + def test_onapvvp_checker_create_log(self, mock_logger): + getlogger_obj = Mock() + logger_obj = Mock() + logger_obj.getLogger.return_value = getlogger_obj + mock_logger.Logger.return_value = logger_obj + + dt_report.OnapVvpChecker.create_log() + + self.assertEqual(getlogger_obj, dt_report.OnapVvpChecker.logger) + + def test_onapvvp_check_result_none(self): testcase_obj = Mock() result = {} - dt_report.VnftestChecker.check(testcase_obj, result) + dt_report.OnapVvpChecker.check(testcase_obj, result) testcase_obj.passed.assert_called_once_with('FAIL') - def test_checker_factory(self): - result = dt_report.CheckerFactory.create('shell') - self.assertEquals(dt_report.ShellChecker, result.__class__) + def test_onapvvp_check_result(self): + testcase_obj = Mock() + result = {'criteria': 'PASS'} - def test_checker_factory_none(self): - self.assertEquals(None, dt_report.CheckerFactory.create('other')) + dt_report.OnapVvpChecker.check(testcase_obj, result) + + testcase_obj.passed.assert_called_once_with('PASS') + + @patch('dovetail.report.dt_cfg') + @patch('dovetail.report.os.path') + @patch('builtins.open') + @patch('dovetail.report.os.getenv') + def test_get_checksum_tosca(self, mock_env, mock_open, mock_path, + mock_config): + mock_config.dovetail_config = { + 'config_dir': 'config_dir' + } + mock_env.return_value = 'csar_file' + file_obj = Mock() + file_obj.read.return_value = 'info' + file_obj.__exit__ = Mock() + file_obj.__enter__ = Mock() + mock_open.return_value = file_obj + mock_path.isdir.return_value = False + mock_path.isfile.return_value = True + + dt_report.Report.get_checksum('tosca') + + @patch('dovetail.report.dt_cfg') + @patch('dovetail.report.os.path') + @patch('dovetail.report.os.walk') + @patch('builtins.open') + @patch('dovetail.report.os.getenv') + def test_get_checksum_heat(self, mock_env, mock_open, mock_walk, mock_path, + mock_config): + mock_config.dovetail_config = { + 'config_dir': 'config_dir' + } + mock_env.return_value = 'heat_templates_archive' + file_obj = Mock() + file_obj.read.return_value = 'info' + file_obj.__exit__ = Mock() + file_obj.__enter__ = Mock() + mock_open.return_value = file_obj + mock_path.isdir.return_value = True + mock_walk.return_value = [('root', ['dir'], ['file'])] + + dt_report.Report.get_checksum('heat') diff --git a/dovetail/tests/unit/test_run.py b/dovetail/tests/unit/test_run.py index c7fe4d6d..c1e37116 100644 --- a/dovetail/tests/unit/test_run.py +++ b/dovetail/tests/unit/test_run.py @@ -46,7 +46,7 @@ class RunTesting(unittest.TestCase): mock_testsuite.load.assert_called_once_with() mock_testsuite.get.assert_called_once_with('testsuite') - self.assertEquals('suite_a', result) + self.assertEqual('suite_a', result) @patch('dovetail.run.dt_report.Report') def test_run_test_no_list(self, mock_report): @@ -57,30 +57,45 @@ class RunTesting(unittest.TestCase): logger.warning.assert_called_once_with( "No test case will be executed.") + @patch('dovetail.run.datetime') + @patch('dovetail.run.dt_utils') @patch('dovetail.run.dt_cfg') @patch('dovetail.run.dt_report.Report') @patch('dovetail.run.dt_testcase.Testcase') @patch('dovetail.run.time') - def test_run_test(self, mock_time, mock_testcase, mock_report, - mock_config): + @patch('os.getenv') + def test_run_test(self, mock_getenv, mock_time, mock_testcase, mock_report, + mock_config, mock_utils, mock_datetime): logger = Mock() report_obj = Mock() mock_report.return_value = report_obj - mock_time.time.side_effect = [42, 84] + mock_time.time.side_effect = [42, 43, 83, 84] + datetime_obj = Mock() + mock_datetime.fromtimestamp.return_value = datetime_obj + datetime_obj.strftime.side_effect = ['1969-12-31 19:00:43', + '1969-12-31 19:01:23'] testcase_name = 'testcase' testcase_obj = Mock() mock_testcase.get.return_value = testcase_obj mock_config.dovetail_config = {'stop': True} + mock_getenv.return_value = 'true' report_obj.check_tc_result.return_value = {'criteria': 'PASS'} + mock_utils.push_results_to_db.return_value = True dt_run.run_test([testcase_name], True, logger) - mock_time.time.assert_has_calls([call(), call()]) + mock_time.time.assert_has_calls([call(), call(), call(), call()]) logger.info.assert_called_once_with( '>>[testcase]: {}'.format(testcase_name)) mock_testcase.get.assert_called_once_with(testcase_name) testcase_obj.run.assert_called_once_with() report_obj.check_tc_result.assert_called_once_with(testcase_obj) + mock_utils.push_results_to_db.assert_called_once_with( + case_name=testcase_name, + start_date='1969-12-31 19:00:43', + stop_date='1969-12-31 19:01:23', + details={'criteria': 'PASS'}, + logger=logger) report_obj.generate.assert_called_once_with([testcase_name], 42) report_obj.save_logs.assert_called_once_with() @@ -101,7 +116,8 @@ class RunTesting(unittest.TestCase): dt_run.run_test([testcase_name], True, logger) - mock_time.time.assert_called_once_with() + mock_time.time.assert_has_calls([call(), call(), call().__float__(), + call(), call().__float__()]) logger.info.assert_has_calls([ call('>>[testcase]: {}'.format(testcase_name)), call('Stop because {} failed'.format(testcase_name))]) @@ -127,7 +143,7 @@ class RunTesting(unittest.TestCase): dt_run.run_test([testcase_name], True, logger) - mock_time.time.assert_called_once_with() + mock_time.time.assert_has_calls([call(), call(), call()]) logger.info.assert_has_calls([ call('>>[testcase]: {}'.format(testcase_name)), call('Stop because {} failed'.format(testcase_name))]) @@ -166,14 +182,14 @@ class RunTesting(unittest.TestCase): result = dt_run.filter_config(input_dict, Mock()) - self.assertEquals(expected_dict, result) + self.assertEqual(expected_dict, result) @patch('dovetail.run.dt_cfg') def test_filter_config_none(self, mock_config): mock_config.dovetail_config = {'cli': {}} result = dt_run.filter_config({}, Mock()) - self.assertEquals(None, result) + self.assertEqual(None, result) @patch('dovetail.run.dt_cfg') def test_filter_config_keyerror(self, mock_config): @@ -211,11 +227,9 @@ class RunTesting(unittest.TestCase): mock_report.Report.create_log.assert_called_once_with() mock_report.FunctestCrawler.create_log.assert_called_once_with() mock_report.YardstickCrawler.create_log.assert_called_once_with() - mock_report.VnftestCrawler.create_log.assert_called_once_with() mock_report.BottlenecksCrawler.create_log.assert_called_once_with() mock_report.FunctestChecker.create_log.assert_called_once_with() mock_report.YardstickChecker.create_log.assert_called_once_with() - mock_report.VnftestChecker.create_log.assert_called_once_with() mock_report.BottlenecksChecker.create_log.assert_called_once_with() mock_testcase.Testcase.create_log.assert_called_once_with() mock_testcase.Testsuite.create_log.assert_called_once_with() @@ -235,7 +249,7 @@ class RunTesting(unittest.TestCase): mock_os.path.exists.assert_called_once_with('value') mock_os.path.isdir.assert_called_once_with('value') mock_utils.exec_cmd.assert_called_once_with( - 'sudo rm -rf value/*', exit_on_error=False, exec_msg_on=False) + 'rm -rf value/*', exit_on_error=False, exec_msg_on=False) @patch('dovetail.run.dt_utils') @patch('dovetail.run.dt_cfg') @@ -259,7 +273,8 @@ class RunTesting(unittest.TestCase): dovetail_home = 'dovetail_home' mock_os.environ = {'DOVETAIL_HOME': dovetail_home} mock_os.path.join.side_effect = [ - 'result_path', 'images_dir', 'pre_config_path', 'patch_set_path'] + 'result_path', 'images_dir', 'pre_config_path', 'patch_set_path', + 'userconfig_dir'] mock_config.dovetail_config = {} result = dt_run.get_result_path() @@ -268,14 +283,16 @@ class RunTesting(unittest.TestCase): call(dovetail_home, 'results'), call(dovetail_home, 'images'), call(dovetail_home, 'pre_config'), - call(dovetail_home, 'patches')]) + call(dovetail_home, 'patches'), + call(dovetail_home, 'userconfig')]) expected_dict = { 'result_dir': 'result_path', 'images_dir': 'images_dir', 'config_dir': 'pre_config_path', - 'patch_dir': 'patch_set_path'} - self.assertEquals(expected_dict, mock_config.dovetail_config) - self.assertEquals(dovetail_home, result) + 'patch_dir': 'patch_set_path', + 'userconfig_dir': 'userconfig_dir'} + self.assertEqual(expected_dict, mock_config.dovetail_config) + self.assertEqual(dovetail_home, result) @patch('dovetail.run.os') def test_get_result_path_exception(self, mock_os): @@ -283,7 +300,7 @@ class RunTesting(unittest.TestCase): result = dt_run.get_result_path() - self.assertEquals(None, result) + self.assertEqual(None, result) @patch('dovetail.run.constants') @patch('dovetail.run.dt_cfg') @@ -291,7 +308,7 @@ class RunTesting(unittest.TestCase): @patch('dovetail.run.os') def test_copy_userconfig_files(self, mock_os, mock_utils, mock_config, mock_constants): - mock_config.dovetail_config = {'config_dir': 'value'} + mock_config.dovetail_config = {'userconfig_dir': 'value'} mock_os.path.isdir.return_value = False mock_constants.USERCONF_PATH = 'value' logger = Mock() @@ -301,7 +318,7 @@ class RunTesting(unittest.TestCase): mock_os.path.isdir.assert_called_once_with('value') mock_os.makedirs.assert_called_once_with('value') mock_utils.exec_cmd.assert_called_once_with( - 'sudo cp -r value/* value', logger, exit_on_error=False) + 'cp -r value/* value', logger, exit_on_error=False) @patch('dovetail.run.constants') @patch('dovetail.run.dt_cfg') @@ -319,7 +336,7 @@ class RunTesting(unittest.TestCase): mock_os.path.isdir.assert_called_once_with('value') mock_os.makedirs.assert_called_once_with('value') mock_utils.exec_cmd.assert_called_once_with( - 'sudo cp -a -r value/* value', logger, exit_on_error=False) + 'cp -a -r value/* value', logger, exit_on_error=False) @patch('dovetail.run.os') def test_update_deploy_scenario(self, mock_os): @@ -329,7 +346,7 @@ class RunTesting(unittest.TestCase): dt_run.update_deploy_scenario(logger, deploy_scenario='a') logger.info.assert_called_once_with('DEPLOY_SCENARIO : %s', 'a') - self.assertEquals({'DEPLOY_SCENARIO': 'a'}, mock_os.environ) + self.assertEqual({'DEPLOY_SCENARIO': 'a'}, mock_os.environ) @patch('dovetail.run.dt_cfg') @patch.object(dt_run, 'filter_config') @@ -355,7 +372,7 @@ class RunTesting(unittest.TestCase): logger.warning.assert_called_once_with( 'Strict API response validation DISABLED.') - self.assertEquals(expected_dict, mock_config.dovetail_config) + self.assertEqual(expected_dict, mock_config.dovetail_config) @patch('dovetail.run.dt_cfg') @patch.object(dt_run, 'filter_config') @@ -377,7 +394,7 @@ class RunTesting(unittest.TestCase): 'no_api_validation': False } - self.assertEquals(expected_dict, mock_config.dovetail_config) + self.assertEqual(expected_dict, mock_config.dovetail_config) def test_check_testcase_list_not_in_list(self): logger = Mock() @@ -386,7 +403,7 @@ class RunTesting(unittest.TestCase): logger.error.assert_called_once_with( 'Test case testcase is not defined.') - self.assertEquals(None, result) + self.assertEqual(None, result) def test_check_testcase_list_none(self): logger = Mock() @@ -394,7 +411,7 @@ class RunTesting(unittest.TestCase): logger.error.assert_called_once_with( 'There is no test case to be executed.') - self.assertEquals(None, result) + self.assertEqual(None, result) @patch('dovetail.run.dt_testcase.Testcase') def test_check_testcase_list(self, mock_testcase): @@ -403,7 +420,7 @@ class RunTesting(unittest.TestCase): result = dt_run.check_testcase_list(testcase_list) - self.assertEquals(testcase_list, result) + self.assertEqual(testcase_list, result) @patch('dovetail.run.dt_testcase.Testcase') @patch.object(dt_run, 'check_testcase_list') @@ -415,7 +432,7 @@ class RunTesting(unittest.TestCase): mock_check.assert_called_once_with(testcase_list, None) mock_testcase.load.assert_called_once_with() - self.assertEquals(testcase_list, result) + self.assertEqual(testcase_list, result) @patch('dovetail.run.dt_cfg') @patch('dovetail.run.dt_testcase.Testcase') @@ -439,7 +456,7 @@ class RunTesting(unittest.TestCase): mock_testcase.get_testcases_for_testsuite.assert_called_once_with( 'testsuite_yaml', 'area') mock_check.assert_called_once_with(testcase_list, None) - self.assertEquals(testcase_list, result) + self.assertEqual(testcase_list, result) @patch('dovetail.run.dt_cfg') @patch('dovetail.run.dt_testcase.Testcase') @@ -455,7 +472,7 @@ class RunTesting(unittest.TestCase): mock_testcase.check_testarea.assert_called_once_with('area') logger.error.assert_called_once_with( 'Test suite suite is not defined.') - self.assertEquals(None, result) + self.assertEqual(None, result) @patch('dovetail.run.dt_cfg') @patch('dovetail.run.dt_testcase.Testcase') @@ -471,9 +488,11 @@ class RunTesting(unittest.TestCase): mock_testcase.check_testarea.assert_called_once_with('area') logger.error.assert_called_once_with( 'Test area area is not defined.') - self.assertEquals(None, result) + self.assertEqual(None, result) + @patch('builtins.open') @patch('dovetail.run.os') + @patch('dovetail.run.json') @patch('dovetail.run.uuid') @patch('dovetail.run.dt_logger') @patch('dovetail.run.dt_cfg') @@ -490,37 +509,44 @@ class RunTesting(unittest.TestCase): def test_main(self, mock_create_logs, mock_run, mock_get_list, mock_copy_patch, mock_copy_userconf, mock_update, mock_parse, mock_clean, mock_get_result, mock_utils, mock_config, - mock_logger, mock_uuid, mock_os): + mock_logger, mock_uuid, mock_json, mock_os, mock_open): mock_config.dovetail_config = {} - mock_os.environ = {} + mock_os.environ = {'DOVETAIL_HOME': 'dovetail_home'} logger_obj = Mock() logger_temp_obj = Mock() + file_obj = Mock() logger_temp_obj.getLogger.return_value = logger_obj mock_logger.Logger.return_value = logger_temp_obj + mock_open.return_value.__enter__.return_value = file_obj + mock_json.dumps.return_value = 'results text' mock_uuid.uuid1.return_value = 42 mock_get_result.return_value = True testcase_list = ['testcase'] mock_get_list.return_value = testcase_list kwargs_dict = { 'debug': True, + 'opnfv_ci': True, 'report': True, 'testsuite': 'testsuite', - 'docker_tag': '2.0.0' + 'docker_tag': '2.0.0', + 'no_api_validation': False } with self.assertRaises(SystemExit) as cm: - dt_run.main([ - '--testsuite=testsuite', '--debug', '--report', '2.0.0']) + dt_run.main(['--testsuite=testsuite', '--debug', '--report', + '2.0.0', '--opnfv-ci']) expected = cm.exception logger_temp_obj.getLogger.assert_called_once_with() mock_logger.Logger.assert_called_once_with('run') mock_uuid.uuid1.assert_called_once_with() - self.assertEquals({'build_tag': 'daily-master-42'}, - mock_config.dovetail_config) + self.assertEqual({'build_tag': 'daily-master-42'}, + mock_config.dovetail_config) mock_get_result.assert_called_once_with() mock_clean.assert_called_once_with() - self.assertEquals({'DEBUG': 'true'}, mock_os.environ) + self.assertEqual({'DOVETAIL_HOME': 'dovetail_home', 'DEBUG': 'true', + 'OPNFV_CI': 'true', 'validation': 'enabled'}, + mock_os.environ) mock_create_logs.assert_called_once_with() logger_obj.info.assert_has_calls([ call('================================================'), @@ -535,7 +561,7 @@ class RunTesting(unittest.TestCase): mock_get_list.assert_called_once_with(logger_obj, **kwargs_dict) mock_run.assert_called_once_with( testcase_list, kwargs_dict['report'], logger_obj) - self.assertEquals(expected.code, 0) + self.assertEqual(expected.code, 0) @patch('dovetail.run.uuid') @patch('dovetail.run.dt_cfg') @@ -551,11 +577,13 @@ class RunTesting(unittest.TestCase): expected = cm.exception mock_uuid.uuid1.assert_called_once_with() - self.assertEquals({'build_tag': 'daily-master-42'}, - mock_config.dovetail_config) + self.assertEqual({'build_tag': 'daily-master-42'}, + mock_config.dovetail_config) mock_get_result.assert_called_once_with() - self.assertEquals(expected.code, 0) + self.assertEqual(expected.code, 0) + @patch('builtins.open') + @patch('dovetail.run.json') @patch('dovetail.run.os') @patch('dovetail.run.uuid') @patch('dovetail.run.dt_logger') @@ -574,37 +602,45 @@ class RunTesting(unittest.TestCase): mock_get_list, mock_copy_patch, mock_copy_userconf, mock_update, mock_clean, mock_get_result, mock_utils, mock_config, - mock_logger, mock_uuid, mock_os): + mock_logger, mock_uuid, mock_os, mock_json, + mock_open): mock_config.dovetail_config = {} - mock_os.environ = {} + mock_os.environ = {'DOVETAIL_HOME': 'dovetail_home'} logger_obj = Mock() logger_temp_obj = Mock() + file_obj = Mock() logger_temp_obj.getLogger.return_value = logger_obj mock_logger.Logger.return_value = logger_temp_obj + mock_open.return_value.__enter__.return_value = file_obj + mock_json.dumps.return_value = 'results text' mock_uuid.uuid1.return_value = 42 mock_get_result.return_value = True mock_get_list.return_value = None kwargs_dict = { 'debug': True, + 'opnfv_ci': False, 'report': True, 'testsuite': 'testsuite', - 'docker_tag': '2.0.0' + 'docker_tag': '2.0.0', + 'no_api_validation': False } with self.assertRaises(SystemExit) as cm: dt_run.main([ '--testsuite=testsuite', '--debug', '--report', '2.0.0']) expected = cm.exception - self.assertEquals(expected.code, 2) + self.assertEqual(expected.code, 2) logger_temp_obj.getLogger.assert_called_once_with() mock_logger.Logger.assert_called_once_with('run') mock_uuid.uuid1.assert_called_once_with() - self.assertEquals({'build_tag': 'daily-master-42'}, - mock_config.dovetail_config) + self.assertEqual({'build_tag': 'daily-master-42'}, + mock_config.dovetail_config) mock_get_result.assert_called_once_with() mock_clean.assert_called_once_with() - self.assertEquals({'DEBUG': 'true'}, mock_os.environ) + self.assertEqual({'DOVETAIL_HOME': 'dovetail_home', 'DEBUG': 'true', + 'OPNFV_CI': 'false', 'validation': 'enabled'}, + mock_os.environ) mock_create_logs.assert_called_once_with() logger_obj.info.assert_has_calls([ call('================================================'), diff --git a/dovetail/tests/unit/test_test_runner.py b/dovetail/tests/unit/test_test_runner.py index 08dbde69..232de7b1 100644 --- a/dovetail/tests/unit/test_test_runner.py +++ b/dovetail/tests/unit/test_test_runner.py @@ -43,65 +43,6 @@ class TestRunnerTesting(unittest.TestCase): @patch('dovetail.test_runner.dt_utils') @patch('dovetail.test_runner.dt_cfg') - def test_pre_copy_no_container(self, mock_config, mock_utils): - t_runner.FunctestRunner.create_log() - mock_config.dovetail_config = {'result_dir': 'result_dir'} - docker_runner = t_runner.FunctestRunner(self.testcase) - - result = docker_runner.pre_copy( - container=None, dest_path=None, - src_file=None, exist_file=None) - - docker_runner.logger.error.assert_called_once_with( - 'Container instance is None.') - self.assertEquals(None, result) - - @patch('dovetail.test_runner.dt_utils') - @patch('dovetail.test_runner.dt_cfg') - def test_pre_copy_no_dest_path(self, mock_config, mock_utils): - t_runner.FunctestRunner.create_log() - mock_config.dovetail_config = {'result_dir': 'result_dir'} - docker_runner = t_runner.FunctestRunner(self.testcase) - - result = docker_runner.pre_copy( - container='container', dest_path=None, - src_file=None, exist_file=None) - - docker_runner.logger.error.assert_called_once_with( - 'There has no dest_path in {} config file.'.format( - self.testcase_name)) - self.assertEquals(None, result) - - @patch('dovetail.test_runner.dt_cfg') - @patch('dovetail.test_runner.os.path') - def test_pre_copy(self, mock_path, mock_config): - t_runner.FunctestRunner.create_log() - docker_runner = t_runner.FunctestRunner(self.testcase) - mock_config.dovetail_config = { - 'functest': { - 'result': { - 'dir': 'result_dir' - }, - 'config': { - 'dir': 'config_dir' - } - } - } - container_obj = Mock() - mock_path.join.return_value = 'join' - - result = docker_runner.pre_copy( - container=container_obj, dest_path='dest_path', - src_file='src_file', exist_file='exist_file') - - mock_path.join.assert_has_calls([ - call('result_dir', 'src_file'), - call('config_dir', 'pre_config', 'exist_file')]) - container_obj.copy_file.assert_called_once_with('join', 'dest_path') - self.assertEquals('dest_path', result) - - @patch('dovetail.test_runner.dt_utils') - @patch('dovetail.test_runner.dt_cfg') @patch('dovetail.test_runner.Container') def test_run_offline_not_exist(self, mock_container, mock_config, mock_utils): @@ -166,41 +107,8 @@ class TestRunnerTesting(unittest.TestCase): docker_img_obj = Mock() container_obj.get_docker_image.return_value = docker_img_obj container_obj.pull_image.return_value = True - container_obj.create.return_value = False - mock_container.return_value = container_obj - - docker_runner.run() - - mock_container.assert_called_once_with(self.testcase) - container_obj.get_docker_image.assert_called_once_with() - container_obj.pull_image.assert_called_once_with(docker_img_obj) - container_obj.create.assert_called_once_with(docker_img_obj) - docker_runner.logger.error.assert_called_once_with( - 'Failed to create container.') - - @patch('dovetail.test_runner.dt_cfg') - @patch('dovetail.test_runner.Container') - @patch.object(t_runner.DockerRunner, 'pre_copy') - def test_run__not_offline_src_file_no_precopy(self, mock_precopy, - mock_container, mock_config): - t_runner.VnftestRunner.create_log() - docker_runner = t_runner.VnftestRunner(self.testcase) - mock_config.dovetail_config = { - 'offline': False - } - container_obj = Mock() - docker_img_obj = Mock() - container_obj.get_docker_image.return_value = docker_img_obj - container_obj.pull_image.return_value = True - container_id = '12345' - container_obj.create.return_value = container_id + container_obj.create.return_value = [None, 'error'] mock_container.return_value = container_obj - dest_path = 'dest_path' - src_file_name = 'src_file' - exist_file_name = 'exist_src_file' - self.testcase.pre_copy_path.side_effect = [ - dest_path, src_file_name, exist_file_name] - mock_precopy.return_value = False docker_runner.run() @@ -208,20 +116,13 @@ class TestRunnerTesting(unittest.TestCase): container_obj.get_docker_image.assert_called_once_with() container_obj.pull_image.assert_called_once_with(docker_img_obj) container_obj.create.assert_called_once_with(docker_img_obj) - docker_runner.logger.debug.assert_called_with( - 'container id: {}'.format(container_id)) - self.testcase.pre_copy_path.assert_has_calls([ - call(dest_path), - call(src_file_name), - call(exist_file_name)]) - mock_precopy.assert_called_once_with( - container_obj, dest_path, src_file_name, exist_file_name) + docker_runner.logger.error.assert_has_calls([ + call('Failed to create container.'), call('error')]) @patch('dovetail.test_runner.dt_utils') @patch('dovetail.test_runner.dt_cfg') @patch('dovetail.test_runner.Container') - @patch.object(t_runner.DockerRunner, 'pre_copy') - def test_run__not_offline_no_prepare(self, mock_precopy, mock_container, + def test_run__not_offline_no_prepare(self, mock_container, mock_config, mock_utils): t_runner.FunctestRunner.create_log() mock_config.dovetail_config = { @@ -236,14 +137,13 @@ class TestRunnerTesting(unittest.TestCase): container_obj.get_docker_image.return_value = docker_img_obj container_obj.pull_image.return_value = True container_id = '12345' - container_obj.create.return_value = container_id + container_msg = 'Successfully to create container.' + container_obj.create.return_value = [container_id, container_msg] mock_container.return_value = container_obj - self.testcase.pre_copy_path.return_value = None self.testcase.pre_condition.return_value = ['cmd'] self.testcase.prepare_cmd.return_value = False self.testcase.post_condition.return_value = ['cmd'] container_obj.exec_cmd.return_value = (1, 'error') - mock_precopy.return_value = False docker_runner.run() @@ -253,10 +153,6 @@ class TestRunnerTesting(unittest.TestCase): container_obj.create.assert_called_once_with(docker_img_obj) docker_runner.logger.debug.assert_called_with( 'container id: {}'.format(container_id)) - self.testcase.pre_copy_path.assert_has_calls([ - call('dest_path'), - call('src_file'), - call('exist_src_file')]) self.testcase.pre_condition.assert_called_once_with() container_obj.exec_cmd.assert_has_calls([ call('cmd'), call('cmd')]) @@ -271,8 +167,7 @@ class TestRunnerTesting(unittest.TestCase): @patch('dovetail.test_runner.dt_utils') @patch('dovetail.test_runner.dt_cfg') @patch('dovetail.test_runner.Container') - @patch.object(t_runner.DockerRunner, 'pre_copy') - def test_run__not_offline_prepare(self, mock_precopy, mock_container, + def test_run__not_offline_prepare(self, mock_container, mock_config, mock_utils): t_runner.FunctestRunner.create_log() mock_config.dovetail_config = { @@ -286,15 +181,14 @@ class TestRunnerTesting(unittest.TestCase): container_obj.get_docker_image.return_value = docker_img_obj container_obj.pull_image.return_value = True container_id = '12345' - container_obj.create.return_value = container_id + container_msg = 'Successfully to create container.' + container_obj.create.return_value = [container_id, container_msg] mock_container.return_value = container_obj - self.testcase.pre_copy_path.return_value = None self.testcase.pre_condition.return_value = ['cmd'] self.testcase.prepare_cmd.return_value = True self.testcase.post_condition.return_value = ['cmd'] self.testcase.cmds = ['cmd'] container_obj.exec_cmd.return_value = (1, 'error') - mock_precopy.return_value = False docker_runner.run() @@ -304,10 +198,6 @@ class TestRunnerTesting(unittest.TestCase): container_obj.create.assert_called_once_with(docker_img_obj) docker_runner.logger.debug.assert_called_with( 'container id: {}'.format(container_id)) - self.testcase.pre_copy_path.assert_has_calls([ - call('dest_path'), - call('src_file'), - call('exist_src_file')]) self.testcase.pre_condition.assert_called_once_with() container_obj.exec_cmd.assert_has_calls([ call('cmd'), call('cmd'), call('cmd')]) @@ -335,7 +225,7 @@ class TestRunnerTesting(unittest.TestCase): mock_utils.get_value_from_dict.assert_has_calls([ call('report.source_archive_files', self.testcase_dict), call('report.dest_archive_files', self.testcase_dict)]) - self.assertEquals(True, result) + self.assertEqual(True, result) @patch('dovetail.test_runner.dt_cfg') @patch('dovetail.test_runner.dt_utils') @@ -358,7 +248,7 @@ class TestRunnerTesting(unittest.TestCase): "Can't find corresponding 'result_dest_files' " "for 'result_source_files' with testcase {}" .format(self.testcase_name)) - self.assertEquals(False, result) + self.assertEqual(False, result) @patch('dovetail.test_runner.dt_cfg') @patch('dovetail.test_runner.dt_utils') @@ -387,7 +277,7 @@ class TestRunnerTesting(unittest.TestCase): mock_os.path.isfile.assert_has_calls([call('src_file_path')]) docker_runner.logger.error.assert_called_once_with( "Can't find file {}.".format('src_file_path')) - self.assertEquals(False, result) + self.assertEqual(False, result) @patch('dovetail.test_runner.dt_cfg') @patch('dovetail.test_runner.dt_utils') @@ -416,7 +306,7 @@ class TestRunnerTesting(unittest.TestCase): mock_os.path.isfile.assert_has_calls([call('src_file_path')]) mock_os.renames.assert_called_once_with( 'src_file_path', 'dest_file_path') - self.assertEquals(True, result) + self.assertEqual(True, result) @patch('dovetail.test_runner.jinja2') def test_render(self, mock_jinja): @@ -429,13 +319,14 @@ class TestRunnerTesting(unittest.TestCase): mock_jinja.Template.assert_called_once_with('task_template') template_obj.render.assert_called_with() - self.assertEquals(render_obj, result) + self.assertEqual(render_obj, result) @patch('dovetail.test_runner.dt_cfg') @patch('dovetail.test_runner.os') def test_add_testcase_info(self, mock_os, mock_config): mock_os.getenv.side_effect = ['os_insecure', 'dovetail_home', 'debug', - 'os_cacert'] + 'os_cacert', 'host_url', 'csar_file', + 'heat_templates_archive'] mock_os.environ = {'DEPLOY_SCENARIO': 'deploy_scenario'} mock_config.dovetail_config = {'build_tag': 'build_tag'} @@ -444,15 +335,19 @@ class TestRunnerTesting(unittest.TestCase): 'testcase': 'testcase_name', 'os_insecure': 'os_insecure', 'deploy_scenario': 'deploy_scenario', 'dovetail_home': 'dovetail_home', 'debug': 'debug', - 'build_tag': 'build_tag', 'cacert': 'os_cacert'} + 'build_tag': 'build_tag', 'cacert': 'os_cacert', + 'host_url': 'host_url', 'csar_file': 'csar_file', + 'heat_templates_archive': 'heat_templates_archive' + } result = t_runner.FunctestRunner._add_testcase_info(self.testcase) self.testcase.validate_testcase.assert_called_once_with() self.testcase.name.assert_called_once_with() mock_os.getenv.assert_has_calls([ call('OS_INSECURE'), call('DOVETAIL_HOME'), call('DEBUG'), - call('OS_CACERT')]) - self.assertEquals(expected, result) + call('OS_CACERT'), call('HOST_URL'), call('CSAR_FILE'), + call('VNF_ARCHIVE_NAME')]) + self.assertEqual(expected, result) @patch('dovetail.test_runner.dt_utils') @patch('dovetail.test_runner.dt_cfg') @@ -478,7 +373,7 @@ class TestRunnerTesting(unittest.TestCase): call('conf_path', docker_runner.config_file_name)]) mock_utils.read_plain_file.assert_called_once_with( 'config_file', docker_runner.logger) - self.assertEquals(None, result) + self.assertEqual(None, result) @patch('dovetail.test_runner.yaml.safe_load') @patch('dovetail.test_runner.dt_utils') @@ -513,7 +408,7 @@ class TestRunnerTesting(unittest.TestCase): mock_add_info.assert_called_once_with(self.testcase) mock_render.assert_called_once_with(True, config_item='item') mock_load.assert_called_once_with('full_task') - self.assertEquals( + self.assertEqual( {'config_dir': 'one', 'pod_file': 'two', 'full_task_yaml': 'full_value', @@ -553,7 +448,7 @@ class TestRunnerTesting(unittest.TestCase): mock_add_info.assert_called_once_with(self.testcase) mock_render.assert_called_once_with(True, config_item='item') mock_load.assert_called_once_with('full_task') - self.assertEquals( + self.assertEqual( {'config_dir': 'one', 'pod_file': 'two', 'full_task_yaml': 'full_value', @@ -599,14 +494,14 @@ class TestRunnerTesting(unittest.TestCase): "Need key '{}' in {}".format('testcase_name', {'key': 'value'})) mock_render.assert_called_once_with(True, config_item='item') mock_load.assert_called_once_with('full_task') - self.assertEquals( + self.assertEqual( {'config_dir': 'one', 'pod_file': 'two', 'full_task_yaml': 'full_value', 'result_dir': 'three'}, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.test_runner.json') @patch('dovetail.test_runner.dt_cfg') @patch('dovetail.test_runner.dt_utils') @@ -651,7 +546,7 @@ class TestRunnerTesting(unittest.TestCase): 'pass': 'FAIL'}) file_obj.write.assert_called_once_with(dump_obj) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.test_runner.dt_cfg') @patch('dovetail.test_runner.dt_utils') @patch('dovetail.test_runner.os.path') @@ -692,7 +587,7 @@ class TestRunnerTesting(unittest.TestCase): result = docker_runner.create(self.testcase) - self.assertEquals(None, result) + self.assertEqual(None, result) @patch('dovetail.test_runner.constants') @patch('dovetail.test_runner.dt_utils') @@ -713,7 +608,7 @@ class TestRunnerTesting(unittest.TestCase): call('conf_path', docker_runner.config_file_name)]) mock_utils.read_plain_file.assert_has_calls([ call('config_file', docker_runner.logger)]) - self.assertEquals(None, result) + self.assertEqual(None, result) @patch('dovetail.test_runner.yaml.safe_load') @patch('dovetail.test_runner.constants') @@ -746,8 +641,72 @@ class TestRunnerTesting(unittest.TestCase): mock_add_info.assert_has_calls([call(self.testcase)]) mock_render.assert_has_calls([call(True, config_item='item')]) mock_load.assert_has_calls([call('full_task')]) - self.assertEquals( + self.assertEqual( {'config_dir': 'one', 'pod_file': 'two', 'full_task_yaml': 'full_value'}, result) + + @patch('dovetail.test_runner.dt_utils') + @patch('dovetail.test_runner.os.path') + @patch('dovetail.test_runner.dt_cfg') + def test_init_onapvtprunner_no_env_file(self, mock_config, mock_path, + mock_utils): + t_runner.OnapVtpRunner.create_log() + mock_path.join.side_effect = ['env_file'] + mock_config.dovetail_config = {'config_dir': 'one', 'env_file': 'two'} + mock_path.isfile.return_value = False + + docker_runner = t_runner.OnapVtpRunner(self.testcase) + + mock_path.join.assert_has_calls([call('one', 'two')]) + mock_path.isfile.assert_called_once() + docker_runner.logger.error.assert_called_once_with( + 'File env_file does not exist.') + + @patch('dovetail.test_runner.dt_utils') + @patch('dovetail.test_runner.os.path') + @patch('dovetail.test_runner.dt_cfg') + def test_init_onapvtprunner(self, mock_config, mock_path, mock_utils): + t_runner.OnapVtpRunner.create_log() + mock_path.join.side_effect = ['env_file'] + mock_config.dovetail_config = {'config_dir': 'one', 'env_file': 'two'} + mock_path.isfile.return_value = True + + t_runner.OnapVtpRunner(self.testcase) + + mock_path.join.assert_has_calls([call('one', 'two')]) + mock_path.isfile.assert_called_once() + mock_utils.source_env.assert_called_once_with('env_file') + + @patch('dovetail.test_runner.dt_utils') + @patch('dovetail.test_runner.os.path') + @patch('dovetail.test_runner.dt_cfg') + def test_init_onapvvprunner_no_env_file(self, mock_config, mock_path, + mock_utils): + t_runner.OnapVvpRunner.create_log() + mock_path.join.side_effect = ['env_file'] + mock_config.dovetail_config = {'config_dir': 'one', 'env_file': 'two'} + mock_path.isfile.return_value = False + + docker_runner = t_runner.OnapVvpRunner(self.testcase) + + mock_path.join.assert_has_calls([call('one', 'two')]) + mock_path.isfile.assert_called_once() + docker_runner.logger.error.assert_called_once_with( + 'File env_file does not exist.') + + @patch('dovetail.test_runner.dt_utils') + @patch('dovetail.test_runner.os.path') + @patch('dovetail.test_runner.dt_cfg') + def test_init_onapvvprunner(self, mock_config, mock_path, mock_utils): + t_runner.OnapVvpRunner.create_log() + mock_path.join.side_effect = ['env_file'] + mock_config.dovetail_config = {'config_dir': 'one', 'env_file': 'two'} + mock_path.isfile.return_value = True + + t_runner.OnapVvpRunner(self.testcase) + + mock_path.join.assert_has_calls([call('one', 'two')]) + mock_path.isfile.assert_called_once() + mock_utils.source_env.assert_called_once_with('env_file') diff --git a/dovetail/tests/unit/test_testcase.py b/dovetail/tests/unit/test_testcase.py index 0d303206..81a8de39 100644 --- a/dovetail/tests/unit/test_testcase.py +++ b/dovetail/tests/unit/test_testcase.py @@ -43,7 +43,7 @@ class TestcaseTesting(unittest.TestCase): tcase.Testcase.create_log() - self.assertEquals(getlogger_obj, tcase.Testcase.logger) + self.assertEqual(getlogger_obj, tcase.Testcase.logger) @patch('dovetail.testcase.Parser') def test_parse_cmd_no_lines(self, mock_parser): @@ -55,7 +55,7 @@ class TestcaseTesting(unittest.TestCase): mock_parser.parse_cmd.assert_called_once_with( 'cmd', testcase) - self.assertEquals(False, result) + self.assertEqual(False, result) @patch('dovetail.testcase.Parser') def test_parse_cmd(self, mock_parser): @@ -70,8 +70,8 @@ class TestcaseTesting(unittest.TestCase): mock_parser.parse_cmd.assert_called_once_with( 'cmd', testcase) logger_obj.debug.assert_called_once_with("cmds: ['cmd_lines']") - self.assertEquals(['cmd_lines'], testcase.cmds) - self.assertEquals(True, result) + self.assertEqual(['cmd_lines'], testcase.cmds) + self.assertEqual(True, result) @patch('dovetail.testcase.dt_cfg') def test_prepare_cmd_no_cmds(self, mock_config): @@ -84,12 +84,12 @@ class TestcaseTesting(unittest.TestCase): logger_obj.error.assert_called_once_with( 'Test case {} has no cmds.'.format(testcase.name())) - self.assertEquals(False, result) + self.assertEqual(False, result) @patch('dovetail.testcase.dt_cfg') @patch.object(tcase.Testcase, 'parse_cmd') def test_prepare_cmd_testcase_cmd(self, mock_parse, mock_config): - testcase = tcase.VnftestTestcase(self.testcase_yaml) + testcase = tcase.ShellTestcase(self.testcase_yaml) testcase.testcase['validate']['cmds'] = ['cmd'] mock_config.dovetail_config = {} mock_parse.return_value = True @@ -97,7 +97,7 @@ class TestcaseTesting(unittest.TestCase): result = testcase.prepare_cmd('type') mock_parse.assert_called_once_with(['cmd']) - self.assertEquals(True, result) + self.assertEqual(True, result) @patch('dovetail.testcase.dt_cfg') @patch.object(tcase.Testcase, 'parse_cmd') @@ -110,22 +110,22 @@ class TestcaseTesting(unittest.TestCase): result = testcase.prepare_cmd('type') mock_parse.assert_called_once_with(['cmd']) - self.assertEquals(True, result) + self.assertEqual(True, result) def test_str(self): - testcase = tcase.Testcase(self.testcase_yaml) + testcase = tcase.OnapVtpTestcase(self.testcase_yaml) result = testcase.__str__() - self.assertEquals(testcase.testcase, result) + self.assertEqual(testcase.testcase, result) def test_objective(self): - testcase = tcase.Testcase(self.testcase_yaml) + testcase = tcase.OnapVvpTestcase(self.testcase_yaml) testcase.testcase['objective'] = 'objective' result = testcase.objective() - self.assertEquals('objective', result) + self.assertEqual('objective', result) @patch('dovetail.testcase.dt_utils') def test_sub_testcase(self, mock_utils): @@ -136,7 +136,7 @@ class TestcaseTesting(unittest.TestCase): mock_utils.get_value_from_dict.assert_called_once_with( 'report.sub_testcase_list', testcase.testcase) - self.assertEquals('value', result) + self.assertEqual('value', result) def test_sub_testcase_passed(self): testcase = tcase.Testcase(self.testcase_yaml) @@ -145,37 +145,49 @@ class TestcaseTesting(unittest.TestCase): result = testcase.sub_testcase_passed('name', 'passed') - logger_obj.debug.assert_called_once_with( - 'sub_testcase_passed: name passed') - self.assertEquals('passed', result) + self.assertEqual('passed', result) def test_validate_type(self): testcase = tcase.Testcase(self.testcase_yaml) result = testcase.validate_type() - self.assertEquals('functest', result) + self.assertEqual('functest', result) def test_validate_testcase(self): testcase = tcase.Testcase(self.testcase_yaml) result = testcase.validate_testcase() - self.assertEquals('tempest_smoke_serial', result) + self.assertEqual('tempest_smoke_serial', result) + + def test_portal_key_file(self): + testcase = tcase.Testcase(self.testcase_yaml) + + result = testcase.portal_key_file() + + self.assertEqual('tempest_logs/tempest_smoke_serial.html', result) + + def test_vnf_type(self): + testcase = tcase.OnapVtpTestcase(self.testcase_yaml) + + result = testcase.vnf_type() + + self.assertEqual('tosca', result) def test_passed(self): testcase = tcase.Testcase(self.testcase_yaml) result = testcase.passed('passed') - self.assertEquals('passed', result) + self.assertEqual('passed', result) def test_set_get_results(self): testcase = tcase.Testcase(self.testcase_yaml) testcase.set_results('results') - self.assertEquals('results', testcase.get_results()) + self.assertEqual('results', testcase.get_results()) def test_pre_condition_exists(self): testcase = tcase.Testcase(self.testcase_yaml) @@ -183,7 +195,7 @@ class TestcaseTesting(unittest.TestCase): result = testcase.pre_condition() - self.assertEquals('pre_condition', result) + self.assertEqual('pre_condition', result) @patch.object(tcase.Testcase, 'pre_condition_cls') def test_pre_condition_not_exists(self, mock_pre_condition): @@ -197,7 +209,7 @@ class TestcaseTesting(unittest.TestCase): mock_pre_condition.assert_called_once_with('functest') logger_obj.debug.assert_called_once_with( 'Test case: {} pre_condition is empty.'.format(testcase.name())) - self.assertEquals(False, result) + self.assertEqual(False, result) def test_pre_copy_path(self): testcase = tcase.Testcase(self.testcase_yaml) @@ -205,14 +217,14 @@ class TestcaseTesting(unittest.TestCase): result = testcase.pre_copy_path('key') - self.assertEquals('value', result) + self.assertEqual('value', result) def test_pre_copy_path_error(self): testcase = tcase.Testcase(self.testcase_yaml) result = testcase.pre_copy_path('key') - self.assertEquals(None, result) + self.assertEqual(None, result) def test_post_condition_exists(self): testcase = tcase.Testcase(self.testcase_yaml) @@ -220,7 +232,7 @@ class TestcaseTesting(unittest.TestCase): result = testcase.post_condition() - self.assertEquals('post_condition', result) + self.assertEqual('post_condition', result) @patch.object(tcase.Testcase, 'post_condition_cls') def test_post_condition_not_exists(self, mock_post_condition): @@ -234,14 +246,13 @@ class TestcaseTesting(unittest.TestCase): mock_post_condition.assert_called_once_with('functest') logger_obj.debug.assert_called_once_with( 'Test case: {} post_condition is empty.'.format(testcase.name())) - self.assertEquals(False, result) + self.assertEqual(False, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.testcase.os.path') @patch('dovetail.testcase.dt_cfg') - @patch.object(tcase.Testcase, 'pre_copy_path') @patch.object(tcase.Testcase, 'sub_testcase') - def test_mk_src_file(self, mock_sub_testcase, mock_pre_copy, mock_config, + def test_mk_src_file(self, mock_sub_testcase, mock_config, mock_path, mock_open): testcase = tcase.Testcase(self.testcase_yaml) logger_obj = Mock() @@ -249,8 +260,6 @@ class TestcaseTesting(unittest.TestCase): mock_config.dovetail_config = {'result_dir': 'value'} sub_test = 'sub_test' file_path = 'file_path' - testcase_src_file = 'testcase_src_file' - mock_pre_copy.return_value = testcase_src_file mock_path.join.return_value = file_path mock_sub_testcase.return_value = [sub_test] file_obj = Mock() @@ -258,21 +267,18 @@ class TestcaseTesting(unittest.TestCase): result = testcase.mk_src_file() - mock_pre_copy.assert_called_once_with('src_file') - mock_path.join.assert_called_once_with('value', testcase_src_file) + mock_path.join.assert_called_once_with('value', 'tempest_custom.txt') mock_open.assert_called_once_with(file_path, 'w+') file_obj.write.assert_called_once_with(sub_test + '\n') - logger_obj.debug.assert_has_calls([ - call('Save test cases {}'.format(sub_test)), - call('Save test cases to {}'.format(file_path))]) - self.assertEquals(file_path, result) + logger_obj.debug.assert_called_once_with( + 'Save test cases to {}'.format(file_path)) + self.assertEqual(file_path, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.testcase.os.path') @patch('dovetail.testcase.dt_cfg') - @patch.object(tcase.Testcase, 'pre_copy_path') @patch.object(tcase.Testcase, 'sub_testcase') - def test_mk_src_file_exception(self, mock_sub_testcase, mock_pre_copy, + def test_mk_src_file_exception(self, mock_sub_testcase, mock_config, mock_path, mock_open): testcase = tcase.Testcase(self.testcase_yaml) logger_obj = Mock() @@ -280,19 +286,16 @@ class TestcaseTesting(unittest.TestCase): mock_config.dovetail_config = {'result_dir': 'value'} sub_test = 'sub_test' file_path = 'file_path' - testcase_src_file = 'testcase_src_file' - mock_pre_copy.return_value = testcase_src_file mock_path.join.return_value = file_path mock_sub_testcase.return_value = [sub_test] mock_open.return_value.__enter__.side_effect = Exception() result = testcase.mk_src_file() - mock_pre_copy.assert_called_once_with('src_file') - mock_path.join.assert_called_once_with('value', testcase_src_file) + mock_path.join.assert_called_once_with('value', 'tempest_custom.txt') mock_open.assert_called_once_with(file_path, 'w+') logger_obj.exception('Failed to save: {}'.format(file_path)) - self.assertEquals(None, result) + self.assertEqual(None, result) @patch('dovetail.testcase.TestRunnerFactory') def test_run(self, mock_factory): @@ -316,28 +319,28 @@ class TestcaseTesting(unittest.TestCase): mock_config.dovetail_config = {'type': {'pre_condition': 'value'}} result = tcase.Testcase.pre_condition_cls('type') - self.assertEquals('value', result) + self.assertEqual('value', result) @patch('dovetail.testcase.dt_cfg') def test_pre_condition_cls_key_error(self, mock_config): mock_config.dovetail_config = {} result = tcase.Testcase.pre_condition_cls('type') - self.assertEquals(None, result) + self.assertEqual(None, result) @patch('dovetail.testcase.dt_cfg') def test_post_condition_cls(self, mock_config): mock_config.dovetail_config = {'type': {'post_condition': 'value'}} result = tcase.Testcase.post_condition_cls('type') - self.assertEquals('value', result) + self.assertEqual('value', result) @patch('dovetail.testcase.dt_cfg') def test_post_condition_cls_key_error(self, mock_config): mock_config.dovetail_config = {} result = tcase.Testcase.post_condition_cls('type') - self.assertEquals(None, result) + self.assertEqual(None, result) def test_increase_retry(self): testcase = tcase.Testcase(self.testcase_yaml) @@ -346,9 +349,9 @@ class TestcaseTesting(unittest.TestCase): for _ in range(0, 42): result = testcase.increase_retry() - self.assertEquals(42, result) + self.assertEqual(42, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.testcase.yaml') @patch('dovetail.testcase.os') @patch('dovetail.testcase.TestcaseFactory') @@ -373,9 +376,9 @@ class TestcaseTesting(unittest.TestCase): mock_open.assert_called_once_with('testcase_path') mock_yaml.safe_load.assert_called_once_with(file_obj) mock_factory.create.assert_called_once_with('value', yaml_dict) - self.assertEquals(runner_obj, tcase.Testcase.get('key')) + self.assertEqual(runner_obj, tcase.Testcase.get('key')) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.testcase.yaml') @patch('dovetail.testcase.os') @patch('dovetail.testcase.TestcaseFactory') @@ -404,41 +407,33 @@ class TestcaseTesting(unittest.TestCase): 'Failed to create test case: file') def test_get_none(self): - self.assertEquals(None, tcase.Testcase.get('unknown')) + self.assertEqual(None, tcase.Testcase.get('unknown')) def test_check_testarea_none(self): - self.assertEquals((True, ['full']), - tcase.Testcase.check_testarea(None)) - - @patch('dovetail.testcase.dt_cfg') - def test_check_testarea_not_in_config(self, mock_config): - mock_config.dovetail_config = {'testarea_supported': []} - self.assertEquals((False, None), - tcase.Testcase.check_testarea(['area'])) + self.assertEqual((True, ['full']), + tcase.Testcase.check_testarea(None)) @patch('dovetail.testcase.dt_cfg') def test_check_testarea_full(self, mock_config): - mock_config.dovetail_config = {'testarea_supported': ['full']} - self.assertEquals((True, ['full']), - tcase.Testcase.check_testarea(['full'])) + self.assertEqual((True, ['full']), + tcase.Testcase.check_testarea(['full'])) @patch('dovetail.testcase.dt_cfg') def test_check_testarea(self, mock_config): - mock_config.dovetail_config = {'testarea_supported': ['area']} - self.assertEquals((True, ['area']), - tcase.Testcase.check_testarea(['area'])) + self.assertEqual((True, ['area']), + tcase.Testcase.check_testarea(['area'])) def test_check_testcase_area(self): - self.assertEquals(False, - tcase.Testcase.check_testcase_area(None, None)) + self.assertEqual(False, + tcase.Testcase.check_testcase_area(None, None)) def test_check_testcase_area_full_or_in_testcase(self): - self.assertEquals(True, - tcase.Testcase.check_testcase_area(['full'], 'full')) + self.assertEqual(True, + tcase.Testcase.check_testcase_area(['full'], 'full')) def test_check_testcase_area_not_in_testcase_or_full(self): - self.assertEquals(False, - tcase.Testcase.check_testcase_area(['full'], 'half')) + self.assertEqual(False, + tcase.Testcase.check_testcase_area(['full'], 'half')) @patch('dovetail.testcase.dt_utils') def test_get_testcases_for_testsuite_no_testcases(self, mock_utils): @@ -450,7 +445,7 @@ class TestcaseTesting(unittest.TestCase): call('testcases_list', 'suite'), call('mandatory', None), call('optional', None)]) - self.assertEquals([], result) + self.assertEqual([], result) @patch('dovetail.testcase.dt_cfg') @patch('dovetail.testcase.dt_utils') @@ -479,7 +474,7 @@ class TestcaseTesting(unittest.TestCase): .format(testsuite['name'])), call('There is no optional test case in test suite {}' .format(testsuite['name']))]) - self.assertEquals(None, result) + self.assertEqual(None, result) @patch('dovetail.testcase.dt_cfg') @patch('dovetail.testcase.dt_utils') @@ -513,10 +508,10 @@ class TestcaseTesting(unittest.TestCase): mock_check.assert_has_calls([ call('mandatory', 'area'), call('optional', 'area')]) - self.assertEquals(['mandatory', 'optional'], result) - self.assertEquals( + self.assertEqual(['mandatory', 'optional'], result) + self.assertEqual( True, tcase.Testcase.testcase_list['mandatory'].is_mandatory) - self.assertEquals( + self.assertEqual( False, tcase.Testcase.testcase_list['optional'].is_mandatory) @patch('dovetail.testcase.dt_cfg') @@ -551,13 +546,12 @@ class TestcaseTesting(unittest.TestCase): mock_check.assert_has_calls([ call('mandatory', 'area'), call('optional', 'area')]) - self.assertEquals(['mandatory', 'optional'], result) - self.assertEquals(True, - tcase.Testcase.testcase_list['mandatory'] - .is_mandatory) - self.assertEquals(False, - tcase.Testcase.testcase_list['optional'] - .is_mandatory) + self.assertEqual(['mandatory', 'optional'], result) + self.assertEqual(True, + tcase.Testcase.testcase_list['mandatory'] + .is_mandatory) + self.assertEqual(False, + tcase.Testcase.testcase_list['optional'].is_mandatory) @patch.object(tcase.Testcase, 'prepare_cmd') def test_functest_case_prepare_cmd_false(self, mock_prepare): @@ -567,7 +561,7 @@ class TestcaseTesting(unittest.TestCase): result = testcase.prepare_cmd('type') mock_prepare.assert_called_once_with('type') - self.assertEquals(False, result) + self.assertEqual(False, result) @patch('dovetail.testcase.os.path') @patch('dovetail.testcase.dt_cfg') @@ -580,30 +574,29 @@ class TestcaseTesting(unittest.TestCase): mock_prepare.return_value = True mock_config.dovetail_config = { 'no_api_validation': True, - 'functest': {'config': {'dir': 'value'}}} + 'functest': {'patches_dir': 'value'}} mock_path.join.return_value = 'patch_cmd' result = testcase.prepare_cmd('type') mock_path.join.assert_called_once_with( - 'value', 'patches', 'functest', 'disable-api-validation', - 'apply.sh') + 'value', 'functest', 'disable-api-validation', 'apply.sh') logger_obj.debug.assert_called_once_with( 'Updated list of commands for test run with ' 'disabled API response validation: {}' .format(testcase.cmds)) - self.assertEquals(['patch_cmd'], testcase.cmds) - self.assertEquals(True, result) + self.assertEqual(['patch_cmd'], testcase.cmds) + self.assertEqual(True, result) def test_testfactory_error(self): - self.assertEquals(None, - tcase.TestcaseFactory.create('unknown', - self.testcase_yaml)) + self.assertEqual(None, + tcase.TestcaseFactory.create('unknown', + self.testcase_yaml)) def test_testfactory_k8s(self): k8s_testcase = tcase.TestcaseFactory.create('functest-k8s', self.testcase_yaml) - self.assertEquals('functest-k8s', k8s_testcase.type) + self.assertEqual('functest-k8s', k8s_testcase.type) @patch('dovetail.testcase.dt_logger') def test_testsuite_create_log(self, mock_logger): @@ -614,7 +607,7 @@ class TestcaseTesting(unittest.TestCase): tcase.Testsuite.create_log() - self.assertEquals(getlogger_obj, tcase.Testsuite.logger) + self.assertEqual(getlogger_obj, tcase.Testsuite.logger) def test_testsuite_get_test(self): suite = tcase.Testsuite('suite') @@ -622,16 +615,16 @@ class TestcaseTesting(unittest.TestCase): result = suite.get_test('testcase') - self.assertEquals('value', result) + self.assertEqual('value', result) def test_testsuite_get_test_not_exists(self): suite = tcase.Testsuite('suite') result = suite.get_test('testcase') - self.assertEquals(None, result) + self.assertEqual(None, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('dovetail.testcase.yaml') @patch('dovetail.testcase.os') @patch('dovetail.testcase.constants') @@ -650,16 +643,16 @@ class TestcaseTesting(unittest.TestCase): mock_os.path.join.assert_called_with('root', 'file') mock_open.assert_called_once_with('file_path') mock_yaml.safe_load.assert_called_once_with(file_obj) - self.assertEquals({'testsuite': 'value'}, - tcase.Testsuite.testsuite_list) + self.assertEqual({'testsuite': 'value'}, + tcase.Testsuite.testsuite_list) def test_testsuite_get_none(self): - self.assertEquals(None, tcase.Testsuite.get('unknown')) + self.assertEqual(None, tcase.Testsuite.get('unknown')) def test_testsuite_get(self): tcase.Testsuite.testsuite_list.update({'key': 'value'}) - self.assertEquals('value', tcase.Testsuite.get('key')) + self.assertEqual('value', tcase.Testsuite.get('key')) def test_testsuite_get_all(self): tcase.Testsuite.testsuite_list.update({'key': 'value'}) - self.assertEquals({'key': 'value'}, tcase.Testsuite.get_all()) + self.assertEqual({'key': 'value'}, tcase.Testsuite.get_all()) diff --git a/dovetail/tests/unit/test_testcase.yaml b/dovetail/tests/unit/test_testcase.yaml index cb947cd9..b4cd3b1d 100644 --- a/dovetail/tests/unit/test_testcase.yaml +++ b/dovetail/tests/unit/test_testcase.yaml @@ -1,11 +1,22 @@ +############################################################################## +# Copyright (c) 2019 opnfv. +# +# 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 +############################################################################## + --- dovetail.ipv6.tc001: name: dovetail.ipv6.tc001 objective: VIM ipv6 operations, to create/delete network, port and subnet in bulk operation + vnf_type: tosca validate: type: functest testcase: tempest_smoke_serial report: + portal_key_file: tempest_logs/tempest_smoke_serial.html sub_testcase_list: - tempest.api.network.test_networks.BulkNetworkOpsIpV6Test.test_bulk_create_delete_network - tempest.api.network.test_networks.BulkNetworkOpsIpV7Test.test_bulk_create_delete_port diff --git a/dovetail/tests/unit/utils/test_dovetail_config.py b/dovetail/tests/unit/utils/test_dovetail_config.py index c7ac5b96..8e835f49 100644 --- a/dovetail/tests/unit/utils/test_dovetail_config.py +++ b/dovetail/tests/unit/utils/test_dovetail_config.py @@ -39,7 +39,7 @@ class DovetailConfigTesting(unittest.TestCase): dovetail_cfg.set_leaf_dict(dict_to_test, ['aa', 'bb', 'cc'], 'val') - self.assertEquals({'aa': {'bb': {'cc': 'val'}}}, dict_to_test) + self.assertEqual({'aa': {'bb': {'cc': 'val'}}}, dict_to_test) @patch.object(DovetailConfig, 'set_leaf_dict') @patch.object(DovetailConfig, 'dovetail_config') diff --git a/dovetail/tests/unit/utils/test_dovetail_logger.py b/dovetail/tests/unit/utils/test_dovetail_logger.py index a8867890..a70c0503 100644 --- a/dovetail/tests/unit/utils/test_dovetail_logger.py +++ b/dovetail/tests/unit/utils/test_dovetail_logger.py @@ -49,7 +49,7 @@ class DovetailLoggerTesting(unittest.TestCase): logger_name = 'name' dovetail_logger = Logger(logger_name) mock_logging.getLogger.assert_called_once_with(logger_name) - self.assertEquals(dovetail_logger.logger.propagate, 0) + self.assertEqual(dovetail_logger.logger.propagate, 0) logger.setLevel.assert_called_once_with(level_const_debug) mock_os.path.exists.assert_called_once_with(file_path) # mock_os.makedirs.assert_called_once_with(file_path) @@ -60,7 +60,7 @@ class DovetailLoggerTesting(unittest.TestCase): file_handler_obj.setLevel.assert_called_once_with(level_const_info) logger.addHandler.assert_has_calls([ call(stream_handler_obj), call(file_handler_obj)]) - self.assertEquals(dovetail_logger.getLogger(), logger) + self.assertEqual(dovetail_logger.getLogger(), logger) @patch('sys.stdout') @patch('dovetail.utils.dovetail_logger.os') @@ -84,7 +84,7 @@ class DovetailLoggerTesting(unittest.TestCase): logger_name = 'name' dovetail_logger = Logger(logger_name) mock_logging.getLogger.assert_called_once_with(logger_name) - self.assertEquals(dovetail_logger.logger.propagate, 0) + self.assertEqual(dovetail_logger.logger.propagate, 0) logger.setLevel.assert_called_once_with(level_const_debug) mock_os.path.exists.assert_called_once_with(file_path) # mock_os.makedirs.assert_called_once_with(file_path) @@ -95,4 +95,4 @@ class DovetailLoggerTesting(unittest.TestCase): file_handler_obj.setLevel.assert_called_once_with(level_const_debug) logger.addHandler.assert_has_calls([ call(stream_handler_obj), call(file_handler_obj)]) - self.assertEquals(dovetail_logger.getLogger(), logger) + self.assertEqual(dovetail_logger.getLogger(), logger) diff --git a/dovetail/tests/unit/utils/test_dovetail_utils.py b/dovetail/tests/unit/utils/test_dovetail_utils.py index 0f0e14f3..7d1fddc1 100644 --- a/dovetail/tests/unit/utils/test_dovetail_utils.py +++ b/dovetail/tests/unit/utils/test_dovetail_utils.py @@ -27,7 +27,7 @@ class DovetailUtilsTesting(unittest.TestCase): pass @patch('sys.stdout') - @patch('__builtin__.print') + @patch('builtins.print') def test_exec_log_no_verbose(self, mock_print, mock_stdout): dovetail_utils.exec_log(verbose=False, logger=None, msg='', level='info', flush=True) @@ -36,7 +36,7 @@ class DovetailUtilsTesting(unittest.TestCase): mock_stdout.flush.assert_not_called() @patch('sys.stdout') - @patch('__builtin__.print') + @patch('builtins.print') def test_exec_log_no_logger_flush(self, mock_print, mock_stdout): message = 'message' @@ -47,7 +47,7 @@ class DovetailUtilsTesting(unittest.TestCase): mock_stdout.flush.assert_called_once() @patch('sys.stdout') - @patch('__builtin__.print') + @patch('builtins.print') def test_exec_log_no_logger_no_flush(self, mock_print, mock_stdout): message = 'message' @@ -134,7 +134,7 @@ class DovetailUtilsTesting(unittest.TestCase): .format(file_path)) self.assertEqual(expected, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('os.path', autospec=True) def test_read_plain_file(self, mock_path, mock_open): file_path = 'known_file' @@ -149,7 +149,7 @@ class DovetailUtilsTesting(unittest.TestCase): mock_open.assert_called_once_with(file_path, 'r') self.assertEqual(expected, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('os.path', autospec=True) def test_read_plain_file_raised_exception(self, mock_path, mock_open): logger = Mock() @@ -182,7 +182,7 @@ class DovetailUtilsTesting(unittest.TestCase): self.assertEqual(expected, result) @patch('yaml.safe_load') - @patch('__builtin__.open') + @patch('builtins.open') @patch('os.path', autospec=True) def test_read_yaml_file(self, mock_path, mock_open, mock_load): file_obj = Mock() @@ -200,7 +200,7 @@ class DovetailUtilsTesting(unittest.TestCase): mock_load.assert_called_once_with(file_obj) self.assertEqual(expected, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('os.path', autospec=True) def test_read_yaml_file_raised_exception(self, mock_path, mock_open): logger = Mock() @@ -227,7 +227,7 @@ class DovetailUtilsTesting(unittest.TestCase): mock_path.isfile.return_value = False logger = Mock() - expected = '' + expected = {} result = dovetail_utils.get_hosts_info(logger) mock_path.join.assert_called_once_with(file_path, 'hosts.yaml') @@ -235,7 +235,7 @@ class DovetailUtilsTesting(unittest.TestCase): self.assertEqual(expected, result) @patch('yaml.safe_load') - @patch('__builtin__.open') + @patch('builtins.open') @patch('os.path', autospec=True) def test_get_hosts_info_not_yaml(self, mock_path, mock_open, mock_load): file_path = 'file_path' @@ -248,7 +248,7 @@ class DovetailUtilsTesting(unittest.TestCase): mock_load.return_value = None logger = Mock() - expected = '' + expected = {} result = dovetail_utils.get_hosts_info(logger) mock_path.join.assert_called_once_with(file_path, 'hosts.yaml') @@ -260,7 +260,7 @@ class DovetailUtilsTesting(unittest.TestCase): self.assertEqual(expected, result) @patch('yaml.safe_load') - @patch('__builtin__.open') + @patch('builtins.open') @patch('os.path', autospec=True) def test_get_hosts_info_no_hosts_info(self, mock_path, mock_open, mock_load): @@ -274,7 +274,7 @@ class DovetailUtilsTesting(unittest.TestCase): mock_load.return_value = {'a': 'b'} logger = Mock() - expected = '' + expected = {} result = dovetail_utils.get_hosts_info(logger) mock_path.join.assert_called_once_with(file_path, 'hosts.yaml') @@ -287,7 +287,7 @@ class DovetailUtilsTesting(unittest.TestCase): self.assertEqual(expected, result) @patch('yaml.safe_load') - @patch('__builtin__.open') + @patch('builtins.open') @patch('os.path', autospec=True) def test_get_hosts_info_no_hostname(self, mock_path, mock_open, mock_load): file_path = 'file_path' @@ -299,7 +299,7 @@ class DovetailUtilsTesting(unittest.TestCase): mock_open.return_value.__enter__.return_value = file_obj mock_load.return_value = {'hosts_info': {'127.0.0.1': []}} - expected = '' + expected = {} result = dovetail_utils.get_hosts_info() mock_path.join.assert_called_once_with(file_path, 'hosts.yaml') @@ -310,7 +310,7 @@ class DovetailUtilsTesting(unittest.TestCase): @patch('dovetail.utils.dovetail_utils.add_hosts_info') @patch('yaml.safe_load') - @patch('__builtin__.open') + @patch('builtins.open') @patch('os.path', autospec=True) def test_get_hosts_info_no_valid_hostname(self, mock_path, mock_open, mock_load, mock_fn): @@ -324,20 +324,20 @@ class DovetailUtilsTesting(unittest.TestCase): hosts_info = {'127.0.0.1': [None]} mock_load.return_value = {'hosts_info': hosts_info} - expected = '' + expected = {} result = dovetail_utils.get_hosts_info() mock_path.join.assert_called_once_with(file_path, 'hosts.yaml') mock_path.isfile.assert_called_once_with(file_complete_name) mock_open.assert_called_once_with(file_complete_name) mock_load.assert_called_once_with(file_obj) - mock_fn.assert_called_once_with(hosts_info.keys()[0], - hosts_info.values()[0]) + mock_fn.assert_called_once_with(list(hosts_info.keys())[0], + list(hosts_info.values())[0]) self.assertEqual(expected, result) @patch('dovetail.utils.dovetail_utils.add_hosts_info') @patch('yaml.safe_load') - @patch('__builtin__.open') + @patch('builtins.open') @patch('os.path', autospec=True) def test_get_hosts_info(self, mock_path, mock_open, mock_load, mock_fn): file_path = 'file_path' @@ -353,7 +353,7 @@ class DovetailUtilsTesting(unittest.TestCase): logger = Mock() names_str = ' '.join(hostnames) - expected = ' --add-host=\'{}\':{} '.format(names_str, hosts_ip) + expected = {names_str: hosts_ip} result = dovetail_utils.get_hosts_info(logger) mock_path.join.assert_called_once_with(file_path, 'hosts.yaml') @@ -430,7 +430,7 @@ class DovetailUtilsTesting(unittest.TestCase): date = '2018-08-10 05:12:27' logger = Mock() - expected = '0m0s' + expected = '0.0m0s' result = dovetail_utils.get_duration(date, date, logger) self.assertEqual(expected, result) @@ -510,15 +510,12 @@ class DovetailUtilsTesting(unittest.TestCase): hosts_obj.add.assert_called_once_with([entry_obj]) hosts_obj.write.assert_called_once() - @patch('dovetail.utils.dovetail_utils.objwalk') - def test_get_obj_by_path(self, mock_walk): - path = dist_path = 'path' - obj = 'obj' - mock_walk.return_value = [(path, obj)] - - expected = obj - result = dovetail_utils.get_obj_by_path(obj, dist_path) + def test_get_obj_by_path(self): + obj = {'list': ['a', 'b'], 'name': 'name'} + dst_path = ('name',) + expected = 'name' + result = dovetail_utils.get_obj_by_path(obj, dst_path) self.assertEqual(expected, result) @patch('dovetail.utils.dovetail_utils.objwalk') @@ -533,7 +530,7 @@ class DovetailUtilsTesting(unittest.TestCase): self.assertEqual(expected, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('os.environ') def test_source_env(self, mock_env, mock_open): file_path = 'file_path' @@ -547,68 +544,47 @@ class DovetailUtilsTesting(unittest.TestCase): mock_open.assert_called_once_with(file_path, 'r') mock_env.update.assert_called_once_with({env_name: env_value}) - @patch('dovetail.utils.dovetail_utils.exec_cmd') - def test_check_docker_version(self, mock_exec): - server_version = client_version = '1.12.3' - server_ret = client_ret = 0 - mock_exec.side_effect = [(server_ret, server_version), - (client_ret, client_version)] + @patch('dovetail.utils.dovetail_utils.docker') + def test_check_docker_version(self, mock_docker): + server_version = '1.12.3' + client_obj = Mock() + mock_docker.from_env.return_value = client_obj + client_obj.version.return_value = {'Version': server_version} logger = Mock() dovetail_utils.check_docker_version(logger) - mock_exec.assert_has_calls( - [call("sudo docker version -f'{{.Server.Version}}'", - logger=logger), - call("sudo docker version -f'{{.Client.Version}}'", - logger=logger)]) logger.debug.assert_has_calls( - [call('docker server version: {}'.format(server_version)), - call('docker client version: {}'.format(client_version))]) + [call('Docker server version: {}'.format(server_version))]) - @patch('dovetail.utils.dovetail_utils.exec_cmd') - def test_check_docker_version_error(self, mock_exec): - server_version = client_version = '1.12.3' - server_ret = client_ret = 1 - mock_exec.side_effect = [(server_ret, server_version), - (client_ret, client_version)] + @patch('dovetail.utils.dovetail_utils.docker') + def test_check_docker_version_error(self, mock_docker): + client_obj = Mock() + mock_docker.from_env.return_value = client_obj + client_obj.version.return_value = {} logger = Mock() dovetail_utils.check_docker_version(logger) - mock_exec.assert_has_calls( - [call("sudo docker version -f'{{.Server.Version}}'", - logger=logger), - call("sudo docker version -f'{{.Client.Version}}'", - logger=logger)]) logger.error.assert_has_calls( [call("Don't support this Docker server version. " - "Docker server should be updated to at least 1.12.3."), - call("Don't support this Docker client version. " - "Docker client should be updated to at least 1.12.3.")]) - - @patch('dovetail.utils.dovetail_utils.exec_cmd') - def test_check_docker_version_less_than(self, mock_exec): - server_version = client_version = '1.12.1' - server_ret = client_ret = 0 - mock_exec.side_effect = [(server_ret, server_version), - (client_ret, client_version)] + "Docker server should be updated to at least 1.12.3.")]) + + @patch('dovetail.utils.dovetail_utils.docker') + def test_check_docker_version_less_than(self, mock_docker): + server_version = '1.12.1' + client_obj = Mock() + mock_docker.from_env.return_value = client_obj + client_obj.version.return_value = {'Version': server_version} logger = Mock() dovetail_utils.check_docker_version(logger) - mock_exec.assert_has_calls( - [call("sudo docker version -f'{{.Server.Version}}'", - logger=logger), - call("sudo docker version -f'{{.Client.Version}}'", - logger=logger)]) logger.error.assert_has_calls( [call("Don't support this Docker server version. " - "Docker server should be updated to at least 1.12.3."), - call("Don't support this Docker client version. " - "Docker client should be updated to at least 1.12.3.")]) + "Docker server should be updated to at least 1.12.3.")]) - @patch('__builtin__.open') + @patch('builtins.open') @patch('os.path') @patch('os.listdir') @patch('json.load') @@ -640,7 +616,7 @@ class DovetailUtilsTesting(unittest.TestCase): file_obj.write.assert_called_once_with(file_content_str) self.assertEqual(expected, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('os.path') @patch('os.listdir') def test_combine_files_read_exception(self, mock_listdir, mock_path, @@ -663,7 +639,7 @@ class DovetailUtilsTesting(unittest.TestCase): 'Failed to read file {}.'.format(file_complete_name)) self.assertEqual(expected, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('os.path') @patch('os.listdir') @patch('json.load') @@ -699,7 +675,7 @@ class DovetailUtilsTesting(unittest.TestCase): self.assertEqual(expected, result) @patch('json.dump') - @patch('__builtin__.open') + @patch('builtins.open') @patch('os.path') @patch('dovetail.utils.dovetail_utils.check_https_enabled') @patch('os.getenv') @@ -818,7 +794,7 @@ class DovetailUtilsTesting(unittest.TestCase): .format(services_exception_msg)) self.assertEqual(expected, result) - @patch('__builtin__.open') + @patch('builtins.open') @patch('os.path') @patch('dovetail.utils.dovetail_utils.check_https_enabled') @patch('os.getenv') @@ -1050,7 +1026,7 @@ class DovetailUtilsTesting(unittest.TestCase): self.assertEqual(expected, result) @patch('os.path') - @patch('__builtin__.open') + @patch('builtins.open') @patch('yaml.safe_load') def test_get_inventory_password(self, mock_load, mock_open, mock_path): name = 'name' @@ -1089,7 +1065,7 @@ class DovetailUtilsTesting(unittest.TestCase): self.assertEqual(expected, result) @patch('os.path') - @patch('__builtin__.open') + @patch('builtins.open') @patch('yaml.safe_load') def test_get_inventory_key_filename(self, mock_load, mock_open, mock_path): name = 'name' @@ -1133,7 +1109,7 @@ class DovetailUtilsTesting(unittest.TestCase): self.assertEqual(expected, result) @patch('os.path') - @patch('__builtin__.open') + @patch('builtins.open') @patch('yaml.safe_load') def test_get_inventory_other(self, mock_load, mock_open, mock_path): name = 'name' @@ -1166,7 +1142,7 @@ class DovetailUtilsTesting(unittest.TestCase): self.assertEqual(expected, result) @patch('os.path') - @patch('__builtin__.open') + @patch('builtins.open') @patch('yaml.safe_load') def test_get_inventory_keyerror(self, mock_load, mock_open, mock_path): name = 'name' @@ -1197,7 +1173,7 @@ class DovetailUtilsTesting(unittest.TestCase): self.assertEqual(expected, result) @patch('os.path') - @patch('__builtin__.open') + @patch('builtins.open') def test_get_inventory_exception(self, mock_open, mock_path): inventory_file_name = 'inventory' pod_file_name = 'pod' @@ -1254,9 +1230,9 @@ class DovetailUtilsTesting(unittest.TestCase): subp_stdout = Mock() subprocess_obj.stdout = subp_stdout subprocess_obj.wait.return_value = 0 - subp_stdout.readline.side_effect = [cmd_output, ''] + subp_stdout.readline.side_effect = [cmd_output.encode()] - expected = (0, 'line') + expected = (0, "b'line'") result = dovetail_utils.exec_cmd( cmd, logger=logger, exit_on_error=True, info=False, exec_msg_on=True, err_msg='', verbose=verbose, @@ -1272,7 +1248,7 @@ class DovetailUtilsTesting(unittest.TestCase): subp_stdout.close.assert_called_once_with() subprocess_obj.wait.assert_called_once_with() mock_getenv.assert_called_once_with('DEBUG') - mock_bar.assert_called_once_with(1) + # mock_bar.assert_called_once_with(1) self.assertEqual(expected, result) @patch('sys.exit') @@ -1297,7 +1273,7 @@ class DovetailUtilsTesting(unittest.TestCase): subp_stdout = Mock() subprocess_obj.stdout = subp_stdout subprocess_obj.wait.return_value = 1 - subp_stdout.readline.side_effect = [cmd_output, ''] + subp_stdout.readline.side_effect = [cmd_output.encode()] dovetail_utils.exec_cmd( cmd, logger=logger, exit_on_error=True, info=False, @@ -1315,7 +1291,7 @@ class DovetailUtilsTesting(unittest.TestCase): subp_stdout.close.assert_called_once_with() subprocess_obj.wait.assert_called_once_with() mock_getenv.assert_called_once_with('DEBUG') - mock_bar.assert_called_once_with(1) + # mock_bar.assert_called_once_with(1) mock_exit.assert_called_once_with(1) @patch('os.path', autospec=True) @@ -1355,3 +1331,72 @@ class DovetailUtilsTesting(unittest.TestCase): mock_host.assert_called_once() mock_endpoint.assert_called_once() mock_hardware.assert_called_once() + + @patch('json.dumps') + @patch('dovetail.utils.dovetail_utils.requests') + @patch('os.getenv') + def test_push_results_to_db(self, mock_getenv, mock_requests, mock_dumps): + logger = Mock() + case_name = 'case_name' + details = {'criteria': 'PASS'} + start_date = 'start_date' + stop_date = 'stop_date' + mock_getenv.side_effect = [ + 'url', 'installer', 'scenario', 'pod_name', 'build_tag', 'version'] + post_req = Mock() + post_req.raise_for_status.return_value = None + mock_requests.post.return_value = post_req + mock_dumps.return_value = {"project_name": "dovetail"} + + dovetail_utils.push_results_to_db( + case_name, details, start_date, stop_date, logger) + + mock_requests.post.assert_called_once_with( + 'url', + data={"project_name": "dovetail"}, + headers={"Content-Type": "application/json"}) + logger.debug.assert_called_once_with( + "The results were successfully pushed to DB.") + + @patch('json.dumps') + @patch('dovetail.utils.dovetail_utils.requests') + @patch('os.getenv') + def test_push_results_to_db_exception(self, mock_getenv, mock_requests, + mock_dumps): + logger = Mock() + case_name = 'case_name' + details = {'criteria': 'PASS'} + start_date = 'start_date' + stop_date = 'stop_date' + mock_getenv.side_effect = [ + 'url', 'installer', 'scenario', 'pod_name', 'build_tag', 'version'] + post_req = Mock() + post_req.raise_for_status.side_effect = Exception() + mock_requests.post.return_value = post_req + mock_dumps.return_value = {"project_name": "dovetail"} + dovetail_utils.push_results_to_db( + case_name, details, start_date, stop_date, logger) + + logger.debug.assert_not_called() + logger.exception.assert_called_once_with( + "The results cannot be pushed to DB.") + + def test_get_mount_list_error_mount(self): + project_cfg = {'mounts': ['aaa']} + res, msg = dovetail_utils.get_mount_list(project_cfg) + self.assertEqual(None, res) + self.assertEqual('Error mount aaa.', msg) + + def test_get_mount_list_keyerror_exception(self): + project_cfg = {'mounts': ['aaa=a,bbb=b', '']} + res, msg = dovetail_utils.get_mount_list(project_cfg) + self.assertEqual(None, res) + self.assertEqual("'target'", str(msg)) + + def test_get_mount_list(self): + project_cfg = {'mounts': ['target=a,source=b', '']} + res, msg = dovetail_utils.get_mount_list(project_cfg) + expected = [{'Source': 'b', 'Type': 'bind', 'ReadOnly': False, + 'Target': 'a'}] + self.assertEqual(expected, res) + self.assertEqual('Successfully to get mount list.', msg) |