diff options
Diffstat (limited to 'dovetail/tests/unit/test_report.py')
| -rw-r--r-- | dovetail/tests/unit/test_report.py | 1671 |
1 files changed, 1671 insertions, 0 deletions
diff --git a/dovetail/tests/unit/test_report.py b/dovetail/tests/unit/test_report.py new file mode 100644 index 00000000..41d70d2f --- /dev/null +++ b/dovetail/tests/unit/test_report.py @@ -0,0 +1,1671 @@ +#!/usr/bin/env python +# +# Copyright (c) 2018 mokats@intracom-telecom.com and others. +# +# All rights reserved. This program and the accompanying materials +# are made available under the terms of the Apache License, Version 2.0 +# which accompanies this distribution, and is available at +# http://www.apache.org/licenses/LICENSE-2.0 +## + +import json +import os +import unittest +import yaml +from mock import patch, call, Mock + +import dovetail.report as dt_report + +__author__ = 'Stamatis Katsaounis <mokats@intracom-telecom.com>' + + +class ReportTesting(unittest.TestCase): + + def setUp(self): + test_path = os.path.dirname(os.path.realpath(__file__)) + with open(os.path.join(test_path, 'test_testcase.yaml')) as f: + self.testcase_yaml = yaml.safe_load(f) + + def tearDown(self): + pass + + def teardown_method(self, method): + dt_report.FunctestCrawler.logger = None + dt_report.FunctestK8sCrawler.logger = None + dt_report.YardstickCrawler.logger = None + dt_report.BottlenecksCrawler.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.OnapVtpChecker.logger = None + dt_report.OnapVvpChecker.logger = None + dt_report.Report.logger = None + dt_report.Report.results = { + 'functest': {}, 'yardstick': {}, 'functest-k8s': {}, + 'bottlenecks': {}, 'shell': {}, 'onap-vtp': {}, + 'onap-vvp': {}} + + def _produce_report_initial_text(self, report_data): + report_txt = '' + report_txt += '\n\nDovetail Report\n' + report_txt += 'Version: %s\n' % report_data['version'] + report_txt += 'Build Tag: %s\n' % report_data['build_tag'] + report_txt += 'Test Date: %s\n' % report_data['test_date'] + report_txt += 'Duration: %.2f s\n\n' % report_data['duration'] + return report_txt + + @patch('dovetail.report.dt_logger') + def test_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.Report.create_log() + + self.assertEqual(getlogger_obj, dt_report.Report.logger) + + @patch('dovetail.report.os.path') + @patch('dovetail.report.dt_cfg') + @patch('dovetail.report.dt_utils') + @patch.object(dt_report.Report, 'get_result') + @patch.object(dt_report.Report, 'check_result') + def test_check_tc_result(self, mock_check, mock_get, mock_utils, + mock_config, mock_path): + report = dt_report.Report() + logger_obj = Mock() + report.logger = logger_obj + testcase_obj = Mock() + 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_path.join.return_value = 'results_file' + mock_path.isfile.return_value = True + mock_get.return_value = 'result' + + result = report.check_tc_result(testcase_obj) + + mock_utils.get_value_from_dict.assert_called_once_with( + '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 files: [\'results_file\'].') + mock_get.assert_called_once_with(testcase_obj, ['results_file']) + mock_check.assert_called_once_with(testcase_obj, 'result') + self.assertEqual('result', result) + + @patch('dovetail.report.os.path') + @patch('dovetail.report.dt_cfg') + @patch('dovetail.report.dt_utils') + @patch.object(dt_report.Report, 'get_result') + @patch.object(dt_report.Report, 'check_result') + def test_check_tc_result_no_file(self, mock_check, mock_get, mock_utils, + mock_config, mock_path): + report = dt_report.Report() + logger_obj = Mock() + report.logger = logger_obj + testcase_obj = Mock() + 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_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_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.assertEqual(None, result) + + @patch('dovetail.report.os.path') + @patch('dovetail.report.dt_cfg') + @patch('dovetail.report.dt_utils') + @patch.object(dt_report.Report, 'get_result') + @patch.object(dt_report.Report, 'check_result') + def test_check_tc_result_no_check(self, mock_check, mock_get, mock_utils, + mock_config, mock_path): + report = dt_report.Report() + logger_obj = Mock() + report.logger = logger_obj + testcase_obj = Mock() + inner_testcase_obj = Mock() + testcase_obj.testcase = inner_testcase_obj + testcase_obj.name.return_value = 'name' + mock_config.dovetail_config = {'result_dir': 'result_dir'} + mock_utils.get_value_from_dict.return_value = None + + result = report.check_tc_result(testcase_obj) + + mock_utils.get_value_from_dict.assert_called_once_with( + 'report.check_results_files', inner_testcase_obj) + logger_obj.error.assert_called_once_with( + "Failed to get 'check_results_files' from config " + "file of test case name") + mock_check.assert_called_once_with(testcase_obj) + self.assertEqual(None, result) + + @patch('dovetail.report.CheckerFactory') + def test_check_result(self, mock_factory): + testcase_obj = Mock() + testcase_obj.validate_type.return_value = 'type' + checker_obj = Mock() + mock_factory.create.return_value = checker_obj + + dt_report.Report.check_result(testcase_obj) + + testcase_obj.validate_type.assert_called_once_with() + 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, + mock_checksum, 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', + '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] + + result = report.generate_json(testcase_list, 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, + 'validation': 'enabled', + '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.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_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', + '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(testcase_list, duration) + expected = { + 'version': '2018.09', + 'build_tag': 'build_tag', + 'test_date': '2018-01-13 13:13:13 UTC', + 'duration': duration, + '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.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_noVNF_inTestCase(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', + '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' + 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': duration, + 'validation': 'enabled', + '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.assertEqual(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(self, mock_save, mock_generate, mock_config): + logger_obj = Mock() + report = dt_report.Report() + report.logger = logger_obj + 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': '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 = 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.info.assert_called_once_with(expected) + 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_no_cases(self, mock_save, mock_generate, mock_config): + logger_obj = Mock() + report = dt_report.Report() + report.logger = logger_obj + 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': [] + } + mock_generate.return_value = report_data + + result = report.generate([], duration) + expected = self._produce_report_initial_text(report_data) +\ + 'no testcase or all testcases are skipped in this testsuite\n' + + mock_generate.assert_called_once_with([], duration) + mock_save.assert_called_once_with(report_data) + report.logger.info.assert_called_once_with(expected) + self.assertEqual(expected, result) + + @patch('builtins.open') + @patch('dovetail.report.json') + @patch('dovetail.report.os.path') + @patch('dovetail.report.dt_cfg') + def test_save_json_results(self, mock_config, mock_path, mock_json, + mock_open): + mock_config.dovetail_config = { + 'result_dir': 'a', + 'result_file': 'b' + } + mock_path.join.return_value = 'result_file' + file_obj = Mock() + mock_open.return_value.__enter__.return_value = file_obj + mock_json.dumps.return_value = 'results text' + + report = dt_report.Report() + report.save_json_results('results') + + mock_path.join.assert_called_once_with('a', 'b') + mock_open.assert_called_once_with('result_file', 'w') + mock_json.dumps.assert_called_once_with('results') + file_obj.write.assert_called_once_with('results text\n') + + @patch('builtins.open') + @patch('dovetail.report.json') + @patch('dovetail.report.os.path') + @patch('dovetail.report.dt_cfg') + def test_save_json_results_exception(self, mock_config, mock_path, + mock_json, mock_open): + report = dt_report.Report() + logger_obj = Mock() + report.logger = logger_obj + mock_config.dovetail_config = { + 'result_dir': 'a', + 'result_file': 'b' + } + mock_path.join.return_value = 'result_file' + mock_open.return_value.__enter__.side_effect = Exception('error') + + report.save_json_results('results') + + mock_path.join.assert_called_once_with('a', 'b') + mock_open.assert_called_once_with('result_file', 'w') + report.logger.exception.assert_called_once_with( + 'Failed to add result to file result_file, exception: error') + + @patch('dovetail.report.dt_cfg') + @patch('dovetail.report.time') + @patch('dovetail.report.os') + @patch('dovetail.report.tarfile') + def test_save_logs(self, mock_tar, mock_os, mock_time, mock_config): + mock_config.dovetail_config = {'result_dir': 'result_dir'} + local_time_obj = Mock() + mock_time.localtime.return_value = local_time_obj + mock_time.strftime.return_value = '20180113_13:13' + mock_os.getcwd.return_value = 'cwd' + tar_obj = Mock() + tar_file_obj = Mock() + mock_tar.open.return_value.__enter__.return_value = tar_file_obj + mock_os.path.join.side_effect = ['one', tar_obj, 'three'] + mock_os.listdir.return_value = ['file'] + + dt_report.Report.save_logs() + + mock_time.localtime.assert_called_once_with() + mock_time.strftime.assert_called_once_with('%Y%m%d_%H%M', + local_time_obj) + mock_os.getcwd.assert_called_once_with() + mock_os.path.join.assert_has_calls([ + call('result_dir', '..'), + call('result_dir', '..', 'logs_20180113_13:13.tar.gz'), + call('results', 'file')]) + mock_tar.open.assert_called_once_with(tar_obj, 'w:gz') + mock_os.listdir.assert_called_once_with('result_dir') + tar_file_obj.add.assert_called_once_with('three') + mock_os.chdir.assert_has_calls([call('one'), call('cwd')]) + + @patch('dovetail.report.CrawlerFactory') + def test_get_result(self, mock_crawler): + logger_obj = Mock() + report = dt_report.Report() + report.logger = logger_obj + testcase_obj = Mock() + crawler_obj = Mock() + testcase_obj.validate_testcase.return_value = 'validate' + testcase_obj.validate_type.return_value = 'functest' + mock_crawler.create.return_value = crawler_obj + crawler_obj.crawl.return_value = 'result' + + 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_files') + logger_obj.debug.assert_called_once_with( + 'Test case: validate -> result acquired') + 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): + logger_obj = Mock() + report = dt_report.Report() + report.logger = logger_obj + testcase_obj = Mock() + crawler_obj = Mock() + testcase_obj.validate_testcase.return_value = 'validate' + testcase_obj.validate_type.return_value = 'functest' + testcase_obj.increase_retry.return_value = 'retry' + mock_crawler.create.return_value = crawler_obj + crawler_obj.crawl.return_value = None + + 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_files') + testcase_obj.increase_retry.assert_called_once_with() + logger_obj.debug.assert_called_once_with( + 'Test case: validate -> result acquired retry: retry') + self.assertEqual(None, result) + + @patch('dovetail.report.CrawlerFactory') + def test_get_result_no_crawler(self, mock_crawler): + logger_obj = Mock() + report = dt_report.Report() + report.logger = logger_obj + testcase_obj = Mock() + testcase_obj.name.return_value = 'name' + testcase_obj.validate_testcase.return_value = 'validate' + testcase_obj.validate_type.return_value = 'functest' + mock_crawler.create.return_value = None + + 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.assertEqual(None, result) + + @patch('dovetail.report.dt_logger') + def test_functest_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.FunctestCrawler.create_log() + + self.assertEqual(getlogger_obj, dt_report.FunctestCrawler.logger) + + @patch('dovetail.report.dt_cfg') + @patch('dovetail.report.os.path') + def test_functest_crawler_crawl_not_exists(self, mock_path, mock_config): + logger_obj = Mock() + mock_config.dovetail_config = {'build_tag': 'tag'} + dt_report.FunctestCrawler.logger = logger_obj + mock_path.exists.return_value = False + file_path = 'file_path' + testcase_obj = Mock() + testcase_obj.validate_testcase.return_value = 'validate' + testcase_obj.name.return_value = 'name' + + crawler = dt_report.FunctestCrawler() + 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.assertEqual(None, result) + + 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') + @patch('dovetail.report.os.path') + def test_functest_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 = 'name' + testcase_obj.name.return_value = 'name' + testcase_obj.sub_testcase.return_value = ['subt_a'] + file_obj = Mock() + mock_open.return_value.__enter__.return_value = [file_obj] + data_dict = { + 'case_name': 'name', + 'build_tag': 'tag-name', + 'criteria': 'criteria', + 'start_date': 'start_date', + 'stop_date': 'stop_date', + 'details': { + 'tests_number': 'tests_number', + 'failures_number': 'failures_number', + 'success': 'success', + 'failures': 'failures', + 'skipped': 'skipped' + } + } + 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]) + expected = {'criteria': 'criteria', 'timestart': 'start_date', + 'timestop': 'stop_date', 'duration': 'duration', + 'details': { + 'tests': 'tests_number', 'failures': 'failures_number', + 'success': 'success', 'errors': 'failures', + 'skipped': 'skipped'}} + + mock_path.exists.assert_called_once_with(file_path) + mock_open.assert_called_once_with(file_path, 'r') + mock_json.loads.assert_called_once_with(file_obj) + mock_utils.get_duration.assert_called_once_with( + 'start_date', 'stop_date', logger_obj) + testcase_obj.set_results.assert_called_once_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('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('builtins.open') + @patch('dovetail.report.json.loads') + @patch('dovetail.report.dt_cfg') + @patch('dovetail.report.dt_utils') + @patch('dovetail.report.os.path') + def test_functest_crawler_crawl_errors(self, mock_path, mock_utils, + mock_config, mock_load, 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 = 'name' + testcase_obj.name.return_value = 'name' + testcase_obj.sub_testcase.return_value = ['subt_a'] + file_a = Mock() + file_b = Mock() + mock_open.return_value.__enter__.return_value = [file_a, file_b] + mock_load.side_effect = [ValueError(), {}] + mock_utils.get_duration.return_value = 'duration' + + crawler = dt_report.FunctestCrawler() + 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_load.assert_has_calls([call(file_a), call(file_b)]) + testcase_obj.validate_testcase.assert_called_once_with() + testcase_obj.sub_testcase.assert_called_once_with() + testcase_obj.name.assert_called_once_with() + logger_obj.exception.assert_called_once_with( + "Result data don't have key 'case_name'.") + self.assertEqual(None, result) + + @patch('dovetail.report.dt_logger') + def test_functestk8s_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.FunctestK8sCrawler.create_log() + + self.assertEqual(getlogger_obj, dt_report.FunctestK8sCrawler.logger) + + @patch('dovetail.report.FunctestK8sCrawler.crawl_from_file') + @patch('dovetail.report.dt_cfg') + @patch('dovetail.report.os.path') + def test_functestk8s_crawler_crawl_none(self, mock_path, mock_config, + mock_crawl): + logger_obj = Mock() + dt_report.FunctestK8sCrawler.logger = logger_obj + mock_crawl.return_value = None + testcase = 'testcase' + file_path = 'file_path' + + crawler = dt_report.FunctestK8sCrawler() + + result = crawler.crawl(testcase, [file_path]) + + dt_report.FunctestK8sCrawler.crawl_from_file.assert_called_once_with( + 'testcase', 'file_path') + self.assertEqual(None, result) + + @patch('dovetail.report.dt_logger') + def test_yardstick_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.YardstickCrawler.create_log() + + self.assertEqual(getlogger_obj, dt_report.YardstickCrawler.logger) + + @patch('dovetail.report.os.path') + def test_yardstick_crawler_crawl_not_exists(self, mock_path): + logger_obj = Mock() + dt_report.YardstickCrawler.logger = logger_obj + mock_path.exists.return_value = False + file_path = 'file_path' + + crawler = dt_report.YardstickCrawler() + 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.json.loads') + @patch('dovetail.report.dt_utils') + @patch('dovetail.report.os.path') + def test_yardstick_crawler_crawl(self, mock_path, mock_utils, mock_loads, + mock_open): + dt_report.YardstickCrawler.logger = Mock() + mock_path.exists.return_value = True + file_path = 'file_path' + testcase_obj = Mock() + testcase_obj.validate_testcase.return_value = 'name' + file_obj = Mock() + mock_open.return_value.__enter__.return_value = [file_obj] + data_dict = { + 'result': { + 'testcases': { + 'name': { + 'tc_data': [{ + 'data': { + 'sla_pass': 0 + } + }] + } + } + } + } + mock_loads.return_value = data_dict + mock_utils.get_value_from_dict.return_value = 'PASS' + + crawler = dt_report.YardstickCrawler() + 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) + mock_utils.get_value_from_dict.assert_called_once_with( + 'result.criteria', data_dict) + testcase_obj.validate_testcase.assert_called_once_with() + testcase_obj.set_results.assert_called_once_with(expected) + self.assertEqual(expected, result) + + @patch('builtins.open') + @patch('dovetail.report.json.loads') + @patch('dovetail.report.dt_utils') + @patch('dovetail.report.os.path') + def test_yardstick_crawler_crawl_key_error(self, mock_path, mock_utils, + mock_loads, mock_open): + logger_obj = Mock() + dt_report.YardstickCrawler.logger = logger_obj + mock_path.exists.return_value = True + file_path = 'file_path' + testcase_obj = Mock() + testcase_obj.validate_testcase.return_value = 'name' + file_obj = Mock() + mock_open.return_value.__enter__.return_value = [file_obj] + + mock_loads.return_value = {} + mock_utils.get_value_from_dict.return_value = 'PASS' + + crawler = dt_report.YardstickCrawler() + 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) + mock_utils.get_value_from_dict.assert_called_once_with( + 'result.criteria', {}) + testcase_obj.validate_testcase.assert_called_once_with() + testcase_obj.set_results.assert_called_once_with(expected) + logger_obj.exception.assert_called_once_with( + "Pass flag not found 'result'") + self.assertEqual(expected, result) + + @patch('dovetail.report.dt_logger') + def test_bottlenecks_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.BottlenecksCrawler.create_log() + + self.assertEqual(getlogger_obj, dt_report.BottlenecksCrawler.logger) + + @patch('dovetail.report.os.path') + def test_bottlenecks_crawler_crawl_not_exists(self, mock_path): + logger_obj = Mock() + dt_report.BottlenecksCrawler.logger = logger_obj + mock_path.exists.return_value = False + file_path = 'file_path' + + crawler = dt_report.BottlenecksCrawler() + 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.json.loads') + @patch('dovetail.report.os.path') + def test_bottlenecks_crawler_crawl_pass(self, mock_path, mock_loads, + mock_open): + dt_report.BottlenecksCrawler.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 = { + 'data_body': { + 'result': 'PASS' + } + } + mock_loads.return_value = data_dict + + crawler = dt_report.BottlenecksCrawler() + 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.assertEqual(expected, result) + + @patch('builtins.open') + @patch('dovetail.report.json.loads') + @patch('dovetail.report.os.path') + def test_bottlenecks_crawler_crawl_fail(self, mock_path, mock_loads, + mock_open): + dt_report.BottlenecksCrawler.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 = { + 'data_body': { + 'result': 'FAIL' + } + } + mock_loads.return_value = data_dict + + crawler = dt_report.BottlenecksCrawler() + 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_bottlenecks_crawler_crawl_key_error(self, mock_path, mock_loads, + mock_open): + logger_obj = Mock() + dt_report.BottlenecksCrawler.logger = logger_obj + 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.return_value = {} + + crawler = dt_report.BottlenecksCrawler() + 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) + logger_obj.exception.assert_called_once_with( + "Pass flag not found 'data_body'") + self.assertEqual(expected, result) + + @patch('dovetail.report.os.path') + def test_shell_crawler_crawl_not_exists(self, mock_path): + mock_path.exists.return_value = False + file_path = 'file_path' + + crawler = dt_report.ShellCrawler() + result = crawler.crawl(None, [file_path]) + + mock_path.exists.assert_called_once_with(file_path) + self.assertEqual(None, result) + + @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 + file_path = 'file_path' + mock_open.return_value.__enter__.return_value = Exception() + + crawler = dt_report.ShellCrawler() + 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.assertEqual(None, result) + + @patch('builtins.open') + @patch('dovetail.report.json.load') + @patch('dovetail.report.os.path') + def test_shell_crawler_crawl(self, mock_path, mock_load, + mock_open): + mock_path.exists.return_value = True + file_path = 'file_path' + file_obj = Mock() + mock_open.return_value.__enter__.return_value = file_obj + mock_load.return_value = 'result' + + crawler = dt_report.ShellCrawler() + 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.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_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.OnapVvpCrawler.create_log() + + self.assertEqual(getlogger_obj, dt_report.OnapVvpCrawler.logger) + + @patch('dovetail.report.os.path') + def test_onapvtp_crawler_crawl_not_exists(self, mock_path): + logger_obj = Mock() + dt_report.OnapVtpCrawler.logger = logger_obj + mock_path.exists.return_value = False + file_path = '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.assertEqual(None, result) + + @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_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 = { + '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.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) + 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('builtins.open') + @patch('dovetail.report.json.loads') + @patch('dovetail.report.os.path') + def test_onapvtp_crawler_crawl_exception(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 = { + '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 + + 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.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) + 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.assertEqual(dt_report.ShellCrawler, result.__class__) + + def test_crawler_factory_none(self): + self.assertEqual(None, dt_report.CrawlerFactory.create('other')) + + def test_result_checker(self): + self.assertEqual('PASS', dt_report.ResultChecker.check()) + + @patch('dovetail.report.dt_logger') + def test_functest_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.FunctestChecker.create_log() + + self.assertEqual(getlogger_obj, dt_report.FunctestChecker.logger) + + def test_functest_get_sub_testcase_no_result(self): + self.assertEqual( + False, dt_report.FunctestChecker.get_sub_testcase(None, None)) + + def test_functest_get_sub_testcase_simple_match(self): + 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.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.assertEqual( + False, + dt_report.FunctestChecker.get_sub_testcase('subt_a', + ['subt_b'])) + + def test_functest_check_no_db_results(self): + testcase_obj = Mock() + testcase_obj.sub_testcase.return_value = ['subt_a'] + + checker = dt_report.FunctestChecker() + checker.check(testcase_obj, None) + + testcase_obj.sub_testcase.assert_called_once_with() + testcase_obj.sub_testcase_passed.assert_called_once_with( + 'subt_a', 'FAIL') + + def test_functest_check_no_subtestcases(self): + testcase_obj = Mock() + testcase_obj.sub_testcase.return_value = None + + checker = dt_report.FunctestChecker() + checker.check(testcase_obj, {'criteria': 'PASS'}) + + testcase_obj.sub_testcase.assert_called_once_with() + testcase_obj.passed.assert_called_once_with('PASS') + + @patch.object(dt_report.FunctestChecker, 'get_sub_testcase') + def test_functest_check(self, mock_get): + testcase_obj = Mock() + testcase_obj.sub_testcase.return_value = [ + 'subt_a', 'subt_b', 'subt_c', 'subt_d'] + logger_obj = Mock() + dt_report.FunctestChecker.logger = logger_obj + db_result = { + 'criteria': 'PASS', + 'details': { + 'success': True, + 'skipped': False + } + } + mock_get.side_effect = [True, False, True, False, False, KeyError()] + + checker = dt_report.FunctestChecker() + checker.check(testcase_obj, db_result) + + testcase_obj.sub_testcase.assert_called_once_with() + testcase_obj.passed.assert_has_calls([call('PASS'), call('FAIL')]) + + @patch('dovetail.report.dt_logger') + def test_functestk8s_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.FunctestK8sChecker.create_log() + + self.assertEqual(getlogger_obj, dt_report.FunctestK8sChecker.logger) + + @patch('dovetail.report.dt_logger') + def test_yardstick_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.YardstickChecker.create_log() + + self.assertEqual(getlogger_obj, dt_report.YardstickChecker.logger) + + def test_yardstick_check_result(self): + testcase_obj = Mock() + result = {'criteria': 'PASS'} + + dt_report.YardstickChecker.check(testcase_obj, result) + + testcase_obj.passed.assert_called_once_with('PASS') + + def test_yardstick_check_result_none(self): + testcase_obj = Mock() + result = {} + + dt_report.YardstickChecker.check(testcase_obj, result) + + testcase_obj.passed.assert_called_once_with('FAIL') + + @patch('dovetail.report.dt_logger') + def test_bottlenecks_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.BottlenecksChecker.create_log() + + self.assertEqual(getlogger_obj, dt_report.BottlenecksChecker.logger) + + def test_bottlenecks_check_result(self): + testcase_obj = Mock() + result = {'criteria': 'PASS'} + + dt_report.BottlenecksChecker.check(testcase_obj, result) + + testcase_obj.passed.assert_called_once_with('PASS') + + def test_bottlenecks_check_result_none(self): + testcase_obj = Mock() + result = {} + + dt_report.BottlenecksChecker.check(testcase_obj, result) + + testcase_obj.passed.assert_called_once_with('FAIL') + + def test_shell_check_result(self): + testcase_obj = Mock() + result = {'pass': True} + + dt_report.ShellChecker.check(testcase_obj, result) + + testcase_obj.passed.assert_called_once_with(True) + + def test_shell_check_result_exception(self): + testcase_obj = Mock() + result = {} + + dt_report.ShellChecker.check(testcase_obj, result) + + 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_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.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) + + testcase_obj.passed.assert_called_once_with('FAIL') + + def test_onapvtp_check_result(self): + testcase_obj = Mock() + result = {'criteria': 'PASS'} + + dt_report.OnapVtpChecker.check(testcase_obj, result) + + testcase_obj.passed.assert_called_once_with('PASS') + + @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.OnapVvpChecker.check(testcase_obj, result) + + testcase_obj.passed.assert_called_once_with('FAIL') + + def test_onapvvp_check_result(self): + testcase_obj = Mock() + result = {'criteria': 'PASS'} + + 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') |