def test_get_diff_res_count_unresolved(self): """ Count the unresolved results with no filter. """ base_run_id = self._base_runid new_run_id = self._new_runid base_count = self._cc_client.getRunResultCount([base_run_id], None, None) logging.debug("Base run id: %d", base_run_id) logging.debug("Base count: %d", base_count) base_run_res = get_all_run_results(self._cc_client, base_run_id) print_run_results(base_run_res) new_count = self._cc_client.getRunResultCount([new_run_id], None, None) logging.debug("New run id: %d", new_run_id) logging.debug("New count: %d", new_count) new_run_res = get_all_run_results(self._cc_client, new_run_id) print_run_results(new_run_res) cmp_data = CompareData(runIds=[new_run_id], diffType=DiffType.UNRESOLVED) diff_res = self._cc_client.getRunResultCount([base_run_id], None, cmp_data) self.assertEqual(diff_res, 26)
def test_same_bug_hash(self): """ Test that different report ID's referring the same bug hash can query each other's comments. """ # Get run results for the first run. runid_base = self._test_runs[0].runId logging.debug('Get all run results from the db for runid: ' + str(runid_base)) run_results_base = get_all_run_results(self._cc_client, runid_base) self.assertIsNotNone(run_results_base) self.assertNotEqual(len(run_results_base), 0) bug_base = run_results_base[0] # Get run results for the second run. runid_new = self._test_runs[1].runId logging.debug('Get all run results from the db for runid: ' + str(runid_new)) run_results_new = get_all_run_results(self._cc_client, runid_new) self.assertIsNotNone(run_results_new) self.assertNotEqual(len(run_results_new), 0) bug_new = run_results_new[0] # Both bug have the same bug hash. self.assertEqual(bug_base.bugHash, bug_new.bugHash) # There are no comments available for the bug. comments = self._cc_client.getComments(bug_base.reportId) self.assertEqual(len(comments), 0) comments = self._cc_client.getComments(bug_new.reportId) self.assertEqual(len(comments), 0) # Try to add a new comment for the first bug comment = CommentData(author='Anonymous', message='First msg') success = self._cc_client.addComment(bug_base.reportId, comment) self.assertTrue(success) logging.debug('Bug commented successfully') comments = self._cc_client.getComments(bug_base.reportId) self.assertEqual(len(comments), 1) comments = self._cc_client.getComments(bug_new.reportId) self.assertEqual(len(comments), 1) # Remove the comment for the bug. success = self._cc_client.removeComment(comments[0].id) self.assertTrue(success) logging.debug('Comment removed successfully') comments = self._cc_client.getComments(bug_base.reportId) self.assertEqual(len(comments), 0) comments = self._cc_client.getComments(bug_new.reportId) self.assertEqual(len(comments), 0)
def test_same_bug_hash(self): """ Test that different report ID's referring the same bug hash can query each other's comments. """ # Get run results for the first run. runid_base = self._test_runs[0].runId logging.debug('Get all run results from the db for runid: ' + str(runid_base)) run_results_base = get_all_run_results(self._cc_client, runid_base) self.assertIsNotNone(run_results_base) self.assertNotEqual(len(run_results_base), 0) bug_base = run_results_base[0] # Get run results for the second run. runid_new = self._test_runs[1].runId logging.debug('Get all run results from the db for runid: ' + str(runid_new)) run_results_new = get_all_run_results(self._cc_client, runid_new) self.assertIsNotNone(run_results_new) self.assertNotEqual(len(run_results_new), 0) bug_new = run_results_new[0] # Both bug have the same bug hash. self.assertEqual(bug_base.bugHash, bug_new.bugHash) # There are no comments available for the bug. comments = self._cc_client.getComments(bug_base.reportId) self.assertEqual(len(comments), 0) comments = self._cc_client.getComments(bug_new.reportId) self.assertEqual(len(comments), 0) # Try to add a new comment for the first bug comment = CommentData(author='Anonymous', message='First msg') success = self._cc_client.addComment(bug_base.reportId, comment) self.assertTrue(success) logging.debug('Bug commented successfully') comments = self._cc_client.getComments(bug_base.reportId) self.assertEqual(len(comments), 1) comments = self._cc_client.getComments(bug_new.reportId) self.assertEqual(len(comments), 1) # Remove the comment for the bug. success = self._cc_client.removeComment(comments[0].id) self.assertTrue(success) logging.debug('Comment removed successfully') comments = self._cc_client.getComments(bug_base.reportId) self.assertEqual(len(comments), 0) comments = self._cc_client.getComments(bug_new.reportId) self.assertEqual(len(comments), 0)
def test_get_diff_res_count_unresolved(self): """ Count the unresolved results with no filter. """ base_run_id = self._base_runid new_run_id = self._new_runid base_count = self._cc_client.getRunResultCount(base_run_id, []) logging.debug("Base run id: %d", base_run_id) logging.debug("Base count: %d", base_count) base_run_res = get_all_run_results(self._cc_client, base_run_id) print_run_results(base_run_res) new_count = self._cc_client.getRunResultCount(new_run_id, []) logging.debug("New run id: %d", new_run_id) logging.debug("New count: %d", new_count) new_run_res = get_all_run_results(self._cc_client, new_run_id) print_run_results(new_run_res) diff_res = self._cc_client.getDiffResultCount(base_run_id, new_run_id, DiffType.UNRESOLVED, []) # Nothing is resolved. self.assertEqual(diff_res, base_count)
def test_get_diff_res_count_unresolved(self): """ Count the unresolved results with no filter. """ base_run_id = self._base_runid new_run_id = self._new_runid base_count = self._cc_client.getRunResultCount([base_run_id], None, None) print("Base run id: %d", base_run_id) print("Base count: %d", base_count) base_run_res = get_all_run_results(self._cc_client, base_run_id) print_run_results(base_run_res) new_count = self._cc_client.getRunResultCount([new_run_id], None, None) print("New run id: %d", new_run_id) print("New count: %d", new_count) new_run_res = get_all_run_results(self._cc_client, new_run_id) print_run_results(new_run_res) cmp_data = CompareData(runIds=[new_run_id], diffType=DiffType.UNRESOLVED) diff_res = self._cc_client.getRunResultCount([base_run_id], None, cmp_data) self.assertEqual(diff_res, 25)
def test_double_suppress(self): """ Suppressing the same bug for the second time should be successfull. The second suppress should not overwrite the already stored suppress comment. """ runid = self._runid logging.debug('Get all run results from the db for runid: ' + str(runid)) run_results = get_all_run_results(self._cc_client, runid) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) suppress_comment = r'First suppress msg' bug = run_results[0] success = self._cc_client.suppressBug([runid], bug.reportId, suppress_comment) self.assertTrue(success) logging.debug('Bug suppressed successfully') # Try to suppress the same bug again. second_suppress_msg = r'Second suppress msg' success = self._cc_client.suppressBug([runid], bug.reportId, second_suppress_msg) self.assertTrue(success) logging.debug('Same bug suppressed successfully for the second time') simple_filters = [ReportFilter(suppressed=True)] run_results_suppressed = get_all_run_results(self._cc_client, runid, filters=simple_filters) self.assertIsNotNone(run_results_suppressed) self.assertEqual(len(run_results_suppressed), 1) bug_to_suppress = bug bug_to_suppress.suppressed = True bug_to_suppress.suppressComment = suppress_comment # The only one suppressed bug should be returned. self.assertEqual(bug_to_suppress, run_results_suppressed[0]) success = self._cc_client.unSuppressBug([runid], bug_to_suppress.reportId) self.assertTrue(success) logging.debug('Bug unsuppressed successfully') simple_filters = [ReportFilter(suppressed=False)] run_results_unsuppressed = get_all_run_results(self._cc_client, runid, filters=simple_filters) self.assertIsNotNone(run_results_unsuppressed) self.assertEqual(len(run_results), len(run_results_unsuppressed))
def test_disable_checker(self): """ The test depends on a run which was configured for update mode. Compared to the original test analysis in this run the deadcode.Deadstores checker was disabled. """ run_results = get_all_run_results(self._cc_client, self._runid) print_run_results(run_results) # Get check command for the first storage. original_check_command = \ self._cc_client.getCheckCommand(None, self._runid) # Run the anaysis again with different setup. test_project_path = self._testproject_data['project_path'] ret = project.clean(test_project_path) if ret: sys.exit(ret) initial_codechecker_cfg = env.import_test_cfg( self._test_workspace)['codechecker_cfg'] # Disable some checkers for the analysis. deadcode = 'deadcode.DeadStores' initial_codechecker_cfg['checkers'] = ['-d', deadcode] initial_test_project_name = self._run_name ret = codechecker.check_and_store(initial_codechecker_cfg, initial_test_project_name, test_project_path) if ret: sys.exit(1) # Get the results to compare. updated_results = get_all_run_results(self._cc_client, self._runid) all_bugs = self._testproject_data[self._clang_to_test]['bugs'] deadcode_bugs = \ [bug['hash'] for bug in all_bugs if bug['checker'] == deadcode] self.assertEquals(len(updated_results), len(all_bugs)) self.assertTrue(all(map( lambda b: b.detectionStatus == 'unresolved', filter(lambda x: x in deadcode_bugs, updated_results)))) # Get check command for the updated storage. updated_check_command = \ self._cc_client.getCheckCommand(None, self._runid) # Check that the check command is changed. self.assertNotEqual(original_check_command, updated_check_command) self.assertTrue(deadcode not in original_check_command) self.assertTrue(deadcode in updated_check_command)
def test_suppress_comment_in_db(self): """ Exported source suppress comment stored as a review status in the db. """ runid = self._runid logging.debug('Get all run results from the db for runid: ' + str(runid)) run_results = get_all_run_results(self._cc_client, runid) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) bug = run_results[0] report = self._cc_client.getReport(bug.reportId) # Check the stored suppress comment status = ReviewStatus.FALSE_POSITIVE self.assertEqual(report.reviewData.comment, 'deliberate segfault!') self.assertEqual(report.reviewData.status, status) # Change review status to confirmed bug. review_comment = 'This is really a bug' status = ReviewStatus.CONFIRMED success = self._cc_client.changeReviewStatus(bug.reportId, status, review_comment) self.assertTrue(success) logging.debug('Bug review status changed successfully') # Check the same project again. codechecker_cfg = env.import_test_cfg( self._test_workspace)['codechecker_cfg'] initial_test_project_name = self._run_name ret = codechecker.check(codechecker_cfg, initial_test_project_name, self._test_project_path) if ret: sys.exit(1) # Get the results to compare. updated_results = get_all_run_results(self._cc_client, self._runid) self.assertIsNotNone(updated_results) self.assertNotEqual(len(updated_results), 0) bug = updated_results[0] report = self._cc_client.getReport(bug.reportId) # The stored suppress comment for the same bughash is the same. status = ReviewStatus.FALSE_POSITIVE self.assertEqual(report.reviewData.comment, 'deliberate segfault!') self.assertEqual(report.reviewData.status, status)
def test_get_run_results_severity_sort(self): """ Get the run results and sort them by severity and filename ASC. """ runid = self._runid logging.debug('Get all run results from the db for runid: ' + str(runid)) sort_mode1 = SortMode(SortType.SEVERITY, Order.ASC) sort_mode2 = SortMode(SortType.FILENAME, Order.ASC) sort_types = [sort_mode1, sort_mode2] run_result_count = self._cc_client.getRunResultCount(runid, []) self.assertTrue(run_result_count) run_results = get_all_run_results(self._cc_client, runid, sort_types, []) self.assertIsNotNone(run_results) for i in range(run_result_count - 1): bug1 = run_results[i] bug2 = run_results[i + 1] self.assertTrue(bug1.severity <= bug2.severity) self.assertTrue((bug1.severity != bug2.severity) or (bug1.checkedFile <= bug2.checkedFile)) print_run_results(run_results) self.assertEqual(run_result_count, len(run_results))
def test_get_run_results_sorted2(self): """ Get the run results and sort them by file name and checker name ASC. """ runid = self._runid logging.debug('Get all run results from the db for runid: ' + str(runid)) sortMode1 = SortMode(SortType.FILENAME, Order.ASC) sortMode2 = SortMode(SortType.CHECKER_NAME, Order.ASC) sort_types = [sortMode1, sortMode2] run_result_count = self._cc_client.getRunResultCount(runid, []) self.assertTrue(run_result_count) run_results = get_all_run_results(self._cc_client, runid, sort_types, []) self.assertIsNotNone(run_results) print_run_results(run_results) self.assertEqual(run_result_count, len(run_results)) for i in range(run_result_count - 1): bug1 = run_results[i] bug2 = run_results[i + 1] self.assertTrue(bug1.checkedFile <= bug2.checkedFile) self.assertTrue((bug1.checkedFile != bug2.checkedFile) or (bug1.lastBugPosition.startLine <= bug2.lastBugPosition.startLine) or (bug1.checkerId <= bug2.checkerId))
def test_get_run_results_checker_id_and_file_path(self): """ Test if all the bugs are found based on the test project configuration. """ runid = self._runid logging.debug('Get all run results from the db for runid: ' + str(runid)) run_result_count = self._cc_client.getRunResultCount(runid, []) self.assertTrue(run_result_count) run_results = get_all_run_results(self._cc_client, runid) self.assertIsNotNone(run_results) self.assertEqual(run_result_count, len(run_results)) test_project_results = self._testproject_data[ self._clang_to_test]['bugs'] for r in test_project_results: print(r) not_found = find_all(run_results, test_project_results) print_run_results(run_results) if not_found: print("===================") print('Not found bugs:') for bug in not_found: print(bug) print("===================") self.assertEqual(len(not_found), 0)
def test_get_run_results_checker_id_and_file_path(self): """ Test if all the bugs are found based on the test project configuration. """ runid = self._runid logging.debug('Get all run results from the db for runid: ' + str(runid)) run_result_count = self._cc_client.getRunResultCount([runid], None, None) self.assertTrue(run_result_count) run_results = get_all_run_results(self._cc_client, runid) self.assertIsNotNone(run_results) self.assertEqual(run_result_count, len(run_results)) test_project_results = self._testproject_data[ self._clang_to_test]['bugs'] for r in test_project_results: print(r) not_found = find_all(run_results, test_project_results) print_run_results(run_results) if not_found: print("===================") print('Not found bugs:') for bug in not_found: print(bug) print("===================") self.assertEqual(len(not_found), 0)
def test_get_run_results_sorted2(self): """ Get the run results and sort them by file name and checker name ASC. """ runid = self._runid logging.debug('Get all run results from the db for runid: ' + str(runid)) sortMode1 = SortMode(SortType.FILENAME, Order.ASC) sortMode2 = SortMode(SortType.CHECKER_NAME, Order.ASC) sort_types = [sortMode1, sortMode2] run_result_count = self._cc_client.getRunResultCount([runid], None, None) self.assertTrue(run_result_count) run_results = get_all_run_results(self._cc_client, runid, sort_types, None) self.assertIsNotNone(run_results) print_run_results(run_results) self.assertEqual(run_result_count, len(run_results)) for i in range(run_result_count - 1): bug1 = run_results[i] bug2 = run_results[i + 1] self.assertTrue(bug1.checkedFile <= bug2.checkedFile) self.assertTrue((bug1.checkedFile != bug2.checkedFile) or (bug1.line <= bug2.line) or (bug1.checkerId <= bug2.checkerId))
def measure(test_conf, performance_data, store_done, proc_done_counter, proc_counter_lock, keep): """ Fill up a run with the configured values. """ try: log.debug("Generating and storing results ...") number_of_runs = test_conf.get("number_of_runs", 1) # TODO: simulate append by using the same run name in multiple threads run_perf = {} for run_count in range(number_of_runs): run_name = 'name_' + str(run_count) + '_' + str(uuid4()) file_line_size = test_conf.get("file_line_size") file_content = zlib.compress( '\n'.join(['A' * 80] * file_line_size), zlib.Z_BEST_COMPRESSION) with Timer('store', run_perf): run_id = store(test_conf, run_name, file_content) log.debug("Storing results for run " + str(run_id) + " done.") with proc_counter_lock: proc_done_counter.value -= 1 # wait here for other processes to finish storing results # before measuiring queries store_done.wait() view_host, view_port = get_viewer_host_port(test_conf) with CCViewerHelper(view_host, view_port, '/') as viewer_client: with Timer('getRunData', run_perf): viewer_client.getRunData() with Timer('getAllRunResulst', run_perf): res = get_all_run_results(viewer_client, run_id) with Timer('getReportDetails', run_perf): viewer_client.getReportDetails(res[-1].reportId) add_measurement_data(run_id, performance_data, run_perf) clean_after_fill = test_conf.get("clean_after_fill", True) if clean_after_fill and not keep: delete_results(view_host, view_port, run_id, performance_data) except Exception as ex: log.error(ex) with proc_counter_lock: proc_done_counter.value -= 1 sys.exit(1)
def test_sort_review_status_rules(self): """ Test sorting review status rules. """ run_results = get_all_run_results(self._cc_client, self._runid) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) bug1 = run_results[0] bug2 = next(r for r in run_results if r.bugHash != bug1.bugHash) success = self._cc_client.addReviewStatusRule(bug1.bugHash, ReviewStatus.CONFIRMED, 'bug1') self.assertTrue(success) success = self._cc_client.addReviewStatusRule( bug2.bugHash, ReviewStatus.FALSE_POSITIVE, 'bug2') self.assertTrue(success) success = self._cc_client.addReviewStatusRule('invalid', ReviewStatus.INTENTIONAL, 'bug3') self.assertTrue(success) # By default the rules are sorted by the date field in descending # order. rule_filter = None sort_mode = None limit = None offset = 0 rules = self._cc_client.getReviewStatusRules(rule_filter, sort_mode, limit, offset) self.assertEqual(len(rules), 3) self.__check_value_order([r.reviewData.date for r in rules], Order.DESC) # Test ordering rules by date. self.__check_rule_order(lambda r: r.reviewData.date, ReviewStatusRuleSortType.DATE) # Test ordering rules by report hash. self.__check_rule_order(lambda r: r.reportHash, ReviewStatusRuleSortType.REPORT_HASH) # Test ordering rules by author. self.__check_rule_order(lambda r: r.reviewData.author, ReviewStatusRuleSortType.AUTHOR) # Test ordering rules by review status. self.__check_rule_order(lambda r: r.reviewData.status, ReviewStatusRuleSortType.STATUS) # Test ordering rules by associated report count. self.__check_rule_order( lambda r: r.associatedReportCount, ReviewStatusRuleSortType.ASSOCIATED_REPORTS_COUNT)
def test_disable_checker(self): """ The test depends on a run which was configured for update mode. Compared to the original test analysis in this run the deadcode.Deadstores checker was disabled. """ run_results = get_all_run_results(self._cc_client, self._runid) print_run_results(run_results) # Run the anaysis again with different setup. test_project_path = self._testproject_data['project_path'] ret = project.clean(test_project_path) if ret: sys.exit(ret) initial_codechecker_cfg = env.import_test_cfg( self._test_workspace)['codechecker_cfg'] # Disable some checkers for the analysis. deadcode = 'deadcode.DeadStores' initial_codechecker_cfg['checkers'] = ['-d', deadcode] initial_test_project_name = self._run_name ret = codechecker.check(initial_codechecker_cfg, initial_test_project_name, test_project_path) if ret: sys.exit(1) # Get the results to compare. updated_results = get_all_run_results(self._cc_client, self._runid) all_bugs = self._testproject_data[self._clang_to_test]['bugs'] deadcode_bugs = \ [bug['hash'] for bug in all_bugs if bug['checker'] == deadcode] self.assertEquals(len(updated_results), len(all_bugs)) self.assertTrue(all(map( lambda b: b.detectionStatus == 'unresolved', filter(lambda x: x in deadcode_bugs, updated_results))))
def test_skip(self): """ There should be no results from the skipped file. """ runid = self._runid logging.debug('Get all run results from the db for runid: ' + str(runid)) run_results = get_all_run_results(self._cc_client, runid) self.assertIsNotNone(run_results) skipped_files = ["file_to_be_skipped.cpp", "skip.h", "path_end.h"] # IMPORTANT: This test is checking whether some reports are really not # stored because they were skipped during analysis with --skip flag. # However, since clang-tidy is not run, there will be no reports from # "clang-diagnostic" checker. These are handled separately here, # otherwise the test would believe they're missing because of --skip # which is not the case. test_proj_res = self._testproject_data[self._clang_to_test]['bugs'] skipped = [ x for x in test_proj_res if x['file'] in skipped_files or x['checker'].startswith('clang-diagnostic-') ] print("Analysis:") for res in run_results: print(res) print("\nTest config results:") for res in test_proj_res: print(res) print("\nTest config skipped results:") for res in skipped: print(res) missing_results = find_all(run_results, test_proj_res) print_run_results(run_results) print('Missing results:') for mr in missing_results: print(mr) if missing_results: for bug in missing_results: if not bug['checker'].startswith('clang-diagnostic-'): self.assertIn(bug['file'], skipped_files) else: self.assertTrue( True, "There should be missing results because" "using skip") self.assertEqual(len(run_results), len(test_proj_res) - len(skipped))
def test_get_source_file_content(self): """ Test getting the source file content stored to the database. Test unicode support the stored file can be decoded properly compare results form the database to the original file. """ runid = self._runid report_filter = ReportFilter(checkerName=['*'], filepath=['*.c*']) run_result_count = self._cc_client.getRunResultCount([runid], report_filter, None) self.assertTrue(run_result_count) run_results = get_all_run_results(self._cc_client, runid, [], report_filter) self.assertIsNotNone(run_results) for run_res in run_results: self.assertTrue(re.match(r'.*\.c(pp)?$', run_res.checkedFile)) logging.debug('Getting the content of ' + run_res.checkedFile) file_data = self._cc_client.getSourceFileData(run_res.fileId, True, None) self.assertIsNotNone(file_data) file_content1 = file_data.fileContent self.assertIsNotNone(file_content1) with codecs.open(run_res.checkedFile, 'r', 'UTF-8', 'replace') as source_file: file_content2 = source_file.read() self.assertEqual(file_content1, file_content2) file_data_b64 = self._cc_client.getSourceFileData( run_res.fileId, True, Encoding.BASE64) self.assertIsNotNone(file_data_b64) file_content1_b64 = base64.b64decode(file_data_b64.fileContent) self.assertIsNotNone(file_content1_b64) file_content2 = codecs.encode(file_content2, 'utf-8') self.assertEqual(file_content1_b64, file_content2) logging.debug('got ' + str(len(run_results)) + ' files') self.assertEqual(run_result_count, len(run_results))
def test_disable_checker(self): """ The test depends on a run which was configured for update mode. Compared to the original test analysis in this run the deadcode.Deadstores checker was disabled. """ run_results = get_all_run_results(self._cc_client, self._runid) print_run_results(run_results) # Run the anaysis again with different setup. test_project_path = self._testproject_data['project_path'] ret = project.clean(test_project_path) if ret: sys.exit(ret) initial_codechecker_cfg = env.import_test_cfg( self._test_workspace)['codechecker_cfg'] # Disable some checkers for the analysis. deadcode = 'deadcode.DeadStores' initial_codechecker_cfg['checkers'] = ['-d', deadcode] initial_test_project_name = self._run_name ret = codechecker.check(initial_codechecker_cfg, initial_test_project_name, test_project_path) if ret: sys.exit(1) # Get the results to compare. updated_results = get_all_run_results(self._cc_client, self._runid) all_bugs = self._testproject_data[self._clang_to_test]['bugs'] deadcode_bugs = [bug for bug in all_bugs if bug['checker'] == deadcode] self.assertEquals(len(updated_results), len(all_bugs) - len(deadcode_bugs))
def test_get_source_file_content(self): """ Test getting the source file content stored to the database. Test unicode support the stored file can be decoded properly compare results form the database to the original file. """ runid = self._runid report_filter = ReportFilter(checkerName=['*'], filepath=['*.c*']) run_result_count = self._cc_client.getRunResultCount([runid], report_filter, None) self.assertTrue(run_result_count) run_results = get_all_run_results(self._cc_client, runid, [], report_filter) self.assertIsNotNone(run_results) for run_res in run_results: self.assertTrue(re.match(r'.*\.c(pp)?$', run_res.checkedFile)) logging.debug('Getting the content of ' + run_res.checkedFile) file_data = self._cc_client.getSourceFileData(run_res.fileId, True, None) self.assertIsNotNone(file_data) file_content1 = file_data.fileContent self.assertIsNotNone(file_content1) with open(run_res.checkedFile) as source_file: file_content2 = source_file.read() self.assertEqual(file_content1, file_content2) file_data_b64 = self._cc_client.getSourceFileData( run_res.fileId, True, Encoding.BASE64) self.assertIsNotNone(file_data_b64) file_content1_b64 = base64.b64decode(file_data_b64.fileContent) self.assertIsNotNone(file_content1_b64) self.assertEqual(file_content1_b64, file_content2) logging.debug('got ' + str(len(run_results)) + ' files') self.assertEqual(run_result_count, len(run_results))
def test_get_source_file_content_latin1_encoding(self): """ Test if the source file was saved with latin1 encoding. Test if the source file can be read back from the database even if it was not saved with utf-8 encoding. """ runid = self._runid report_filter = ReportFilter(checkerName=['*'], filepath=['*call_and_message.cpp*']) run_result_count = self._cc_client.getRunResultCount([runid], report_filter, None) self.assertTrue(run_result_count) run_results = get_all_run_results(self._cc_client, runid, [], report_filter) self.assertIsNotNone(run_results) self.assertIsNotNone(run_results) for run_res in run_results: print('Getting the content of ' + run_res.checkedFile) file_data = self._cc_client.getSourceFileData(run_res.fileId, True, None) self.assertIsNotNone(file_data) file_content1 = file_data.fileContent self.assertIsNotNone(file_content1) with codecs.open(run_res.checkedFile, 'r', encoding='utf-8', errors='ignore') as source_file: file_content2 = source_file.read() self.assertEqual(file_content1, file_content2) file_data_b64 = self._cc_client.getSourceFileData( run_res.fileId, True, Encoding.BASE64) self.assertIsNotNone(file_data_b64) file_content1_b64 = convert.from_b64(file_data_b64.fileContent) self.assertIsNotNone(file_content1_b64) self.assertEqual(file_content1_b64, file_content2) print('got ' + str(len(run_results)) + ' files') self.assertEqual(run_result_count, len(run_results))
def test_disable_checker(self): """ The test depends on a run which was configured for update mode. Compared to the original test analysis in this run the deadcode.Deadstores checker was disabled. In this case the reports are marked as resolved. """ run_results = get_all_run_results(self._cc_client, self._runid) print_run_results(run_results) # Get check command for the first storage. original_check_command = \ self._cc_client.getCheckCommand(None, self._runid) self.assertEqual(original_check_command, "") initial_codechecker_cfg = env.import_test_cfg( self._test_workspace)['codechecker_cfg'] initial_test_project_name = self._run_name disabled_reports = os.path.join( self._testproject_data['test_project_reports'], 'disabled') initial_codechecker_cfg['reportdir'] = disabled_reports ret = codechecker.store(initial_codechecker_cfg, initial_test_project_name) if ret: sys.exit(1) # Get the results to compare. updated_results = get_all_run_results(self._cc_client, self._runid) for report in updated_results: self.assertEqual(report.detectionStatus, DetectionStatus.RESOLVED)
def test_get_run_results_no_filter(self): """ Get all the run results without any filtering. """ runid = self._runid logging.debug('Get all run results from the db for runid: ' + str(runid)) run_result_count = self._cc_client.getRunResultCount(runid, []) self.assertTrue(run_result_count) run_results = get_all_run_results(self._cc_client, runid) print_run_results(run_results) self.assertIsNotNone(run_results) self.assertEqual(run_result_count, len(run_results))
def test_get_run_results_no_filter(self): """ Get all the run results without any filtering. """ runid = self._runid logging.debug('Get all run results from the db for runid: ' + str(runid)) run_result_count = self._cc_client.getRunResultCount([runid], None, None) self.assertTrue(run_result_count) run_results = get_all_run_results(self._cc_client, runid) print_run_results(run_results) self.assertIsNotNone(run_results) self.assertEqual(run_result_count, len(run_results))
def test_skip(self): """ There should be no results from the skipped file. """ runid = self._runid logging.debug('Get all run results from the db for runid: ' + str(runid)) run_results = get_all_run_results(self._cc_client, runid) self.assertIsNotNone(run_results) skipped_files = ["file_to_be_skipped.cpp", "skip.h"] test_proj_res = self._testproject_data[self._clang_to_test]['bugs'] skipped = [x for x in test_proj_res if x['file'] in skipped_files] print("Analysis:") for res in run_results: print(res) print("\nTest config results:") for res in test_proj_res: print(res) print("\nTest config skipped results:") for res in skipped: print(res) missing_results = find_all(run_results, test_proj_res) print_run_results(run_results) print('Missing results:') for mr in missing_results: print(mr) if missing_results: for bug in missing_results: self.assertIn(bug['file'], skipped_files) else: self.assertTrue(True, "There should be missing results because" "using skip") self.assertEqual(len(run_results), len(test_proj_res) - len(skipped))
def test_get_source_file_content(self): """ Test getting the source file content stored to the database. Test unicode support the stored file can be decoded properly compare results form the database to the original file. """ runid = self._runid simple_filters = [ReportFilter(checkerId='*', filepath='*.c*')] run_result_count = self._cc_client.getRunResultCount( runid, simple_filters) self.assertTrue(run_result_count) run_results = get_all_run_results(self._cc_client, runid, filters=simple_filters) self.assertIsNotNone(run_results) for run_res in run_results: self.assertTrue(re.match(r'.*\.c(pp)?$', run_res.checkedFile)) logging.debug('Getting the content of ' + run_res.checkedFile) file_data = self._cc_client.getSourceFileData(run_res.fileId, True) self.assertIsNotNone(file_data) file_content1 = file_data.fileContent self.assertIsNotNone(file_content1) with open(run_res.checkedFile) as source_file: file_content2 = source_file.read() self.assertEqual(file_content1, file_content2) logging.debug('got ' + str(len(run_results)) + ' files') self.assertEqual(run_result_count, len(run_results))
def test_filter_review_status_rules(self): """ Test filtering review status rules based on different filters. """ run_results = get_all_run_results(self._cc_client, self._runid) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) bug1 = run_results[0] bug2 = next(r for r in run_results if r.bugHash != bug1.bugHash) success = self._cc_client.addReviewStatusRule(bug1.bugHash, ReviewStatus.CONFIRMED, 'bug1') self.assertTrue(success) success = self._cc_client.addReviewStatusRule( bug2.bugHash, ReviewStatus.FALSE_POSITIVE, 'bug2') self.assertTrue(success) rule_filter = None sort_mode = None limit = None offset = 0 # There are two rules in the database. rules = self._cc_client.getReviewStatusRules(rule_filter, sort_mode, limit, offset) self.assertEqual(len(rules), 2) # Show only Confirmed rules. rule_filter = ReviewStatusRuleFilter( reviewStatuses=[ReviewStatus.CONFIRMED]) rules = self._cc_client.getReviewStatusRules(rule_filter, sort_mode, limit, offset) self.assertEqual(len(rules), 1) self.assertEqual(rules[0].reviewData.status, ReviewStatus.CONFIRMED) self.assertEqual( self._cc_client.getReviewStatusRulesCount(rule_filter), 1) # Show both Confirmed and False positive rules. rule_filter = ReviewStatusRuleFilter(reviewStatuses=[ ReviewStatus.CONFIRMED, ReviewStatus.FALSE_POSITIVE ]) rules = self._cc_client.getReviewStatusRules(rule_filter, sort_mode, limit, offset) self.assertEqual(len(rules), 2) self.assertEqual( self._cc_client.getReviewStatusRulesCount(rule_filter), 2) # Filter by report hash. rule_filter = ReviewStatusRuleFilter(reportHashes=[bug1.bugHash]) rules = self._cc_client.getReviewStatusRules(rule_filter, sort_mode, limit, offset) self.assertEqual(len(rules), 1) self.assertEqual(rules[0].reviewData.status, ReviewStatus.CONFIRMED) # Add a review status rule with a non-existing report hash. success = self._cc_client.addReviewStatusRule('invalid', ReviewStatus.INTENTIONAL, 'bug3') self.assertTrue(success) rule_filter = ReviewStatusRuleFilter(noAssociatedReports=True) rules = self._cc_client.getReviewStatusRules(rule_filter, sort_mode, limit, offset) self.assertEqual(len(rules), 1) self.assertEqual(rules[0].reviewData.status, ReviewStatus.INTENTIONAL) self.assertEqual(rules[0].associatedReportCount, 0)
def test_review_status_update_from_source_trim(self): """ Test if the review status comments changes in the source code are updated at the server when trim path is used. The report is store twice and between the storage the review status as a source code comment is modified. The test checks is after the source code modification and storage the review status is updated correctly at the server too. """ test_project_path = os.path.join(self.test_workspace, 'review_status_files') test_project_name = 'review_status_update_proj' plist_file = os.path.join(test_project_path, 'divide_zero.plist') source_file = os.path.join(test_project_path, 'divide_zero.cpp') plist_test.prefix_file_path(plist_file, test_project_path) codechecker_cfg = env.import_codechecker_cfg(self.test_workspace) codechecker_cfg['reportdir'] = test_project_path codechecker.store(codechecker_cfg, test_project_name) codechecker_cfg['trim_path_prefix'] = test_project_path # Run data for the run created by this test case. run_filter = RunFilter(names=[test_project_name], exactMatch=True) runs = self._cc_client.getRunData(run_filter, None, 0, None) run = runs[0] runid = run.runId logging.debug('Get all run results from the db for runid: ' + str(runid)) reports = get_all_run_results(self._cc_client, runid) self.assertIsNotNone(reports) self.assertNotEqual(len(reports), 0) self.assertEqual(len(reports), 2) for report in reports: print(report) self.assertEqual(report.reviewData.status, ReviewStatus.INTENTIONAL) # Modify review comments from intentional to confirmed for the # second store. with open(source_file, 'r+', encoding='utf-8', errors='ignore') as sf: content = sf.read() new_content = content.replace("codechecker_intentional", "codechecker_confirmed") sf.truncate(0) sf.write(new_content) # modify review comments and store the reports again with open(source_file, encoding='utf-8', errors='ignore') as sf: content = sf.read() # Update the plist file modification date to be newer than # the source file so it can be stored, because there was no # actual analysis. date = datetime.datetime.now() + datetime.timedelta(minutes=5) mod_time = time.mktime(date.timetuple()) os.utime(plist_file, (mod_time, mod_time)) codechecker.store(codechecker_cfg, test_project_name) # Check if all the review statuses were updated to the new at the # server. reports = get_all_run_results(self._cc_client, runid) self.assertIsNotNone(reports) self.assertNotEqual(len(reports), 0) self.assertEqual(len(reports), 2) for report in reports: self.assertEqual(report.reviewData.status, ReviewStatus.CONFIRMED)
def test_multiple_change_review_status(self): """ Test changing review status of the same bug. """ runid = self._runid run_results = get_all_run_results(self._cc_client, runid) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) bug = run_results[0] self.__remove_all_comments(bug.reportId) # There are no system comments for this bug. comments = self.__get_system_comments(bug.reportId) self.assertEqual(len(comments), 0) # Change review status to confirmed bug. review_comment = 'This is really a bug' status = ReviewStatus.CONFIRMED success = self._cc_client.addReviewStatusRule(bug.bugHash, status, review_comment) self.assertTrue(success) logging.debug('Bug review status changed successfully') report = self._cc_client.getReport(bug.reportId) self.assertEqual(report.reviewData.comment, review_comment) self.assertEqual(report.reviewData.status, status) # There is one system comment for this bug. comments = self.__get_system_comments(bug.reportId) self.assertEqual(len(comments), 1) # There is only one review status rule in the database. rules = self._cc_client.getReviewStatusRules(None, None, None, 0) self.assertEqual(len(rules), 1) self.assertEqual(rules[0].reportHash, bug.bugHash) self.assertEqual(rules[0].reviewData.comment, review_comment) self.assertEqual(rules[0].reviewData.status, status) self.assertTrue(rules[0].associatedReportCount > 0) self.assertEqual(self._cc_client.getReviewStatusRulesCount(None), 1) # Try to update the review status again with the same data and check # that no new system comment entry will be created. success = self._cc_client.addReviewStatusRule(bug.bugHash, status, review_comment) comments = self.__get_system_comments(bug.reportId) self.assertEqual(len(comments), 1) self.assertEqual(self._cc_client.getReviewStatusRulesCount(None), 1) # Test that updating only the review status message a new system # comment will be created. success = self._cc_client.addReviewStatusRule( bug.bugHash, status, "test system comment change") self.assertTrue(success) comments = self.__get_system_comments(bug.reportId) self.assertEqual(len(comments), 2) self.assertEqual(self._cc_client.getReviewStatusRulesCount(None), 1) # Try to change review status back to unreviewed. status = ReviewStatus.UNREVIEWED success = self._cc_client.addReviewStatusRule(bug.bugHash, status, None) self.assertTrue(success) logging.debug("Bug review status changed successfully") report = self._cc_client.getReport(bug.reportId) self.assertEqual(report.reviewData.comment, '') self.assertEqual(report.reviewData.status, status) # Change review status to false positive. review_comment = 'This is not a bug' status = ReviewStatus.FALSE_POSITIVE success = self._cc_client.addReviewStatusRule(bug.bugHash, status, review_comment) self.assertTrue(success) logging.debug('Bug review status changed successfully') report = self._cc_client.getReport(bug.reportId) self.assertEqual(report.reviewData.comment, review_comment) self.assertEqual(report.reviewData.status, status) # Change review status to intentional. review_comment = '' status = ReviewStatus.INTENTIONAL success = self._cc_client.addReviewStatusRule(bug.bugHash, status, review_comment) self.assertTrue(success) logging.debug('Bug review status changed successfully') report = self._cc_client.getReport(bug.reportId) self.assertEqual(report.reviewData.comment, review_comment) self.assertEqual(report.reviewData.status, status) # Make sure that removing a review status rule will change the review # status information of a report back to default values. self.__remove_all_rules() report = self._cc_client.getReport(bug.reportId) self.assertEqual(report.reviewData.comment, None) self.assertEqual(report.reviewData.author, None) self.assertEqual(report.reviewData.date, None) self.assertEqual(report.reviewData.status, ReviewStatus.UNREVIEWED)
def test_comment(self): """ Test commenting of multiple bugs. """ runid = self._test_runs[0].runId logging.debug('Get all run results from the db for runid: ' + str(runid)) run_results = get_all_run_results(self._cc_client, runid) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) bug = run_results[0] # There are no comments available for the first bug comments = self._cc_client.getComments(bug.reportId) self.assertEqual(len(comments), 0) num_comment = self._cc_client.getCommentCount(bug.reportId) self.assertEqual(num_comment, 0) # Try to add a new comment for the first bug comment1 = CommentData(author='anybody', message='First msg') success = self._cc_client.addComment(bug.reportId, comment1) self.assertTrue(success) logging.debug('Bug commented successfully') # Try to add another new comment for the first bug comment2 = CommentData(author='anybody', message='Second msg') success = self._cc_client.addComment(bug.reportId, comment2) self.assertTrue(success) logging.debug('Bug commented successfully') # Try to add another new comment with empty message. with self.assertRaises(RequestFailed): self._cc_client.addComment(bug.reportId, CommentData(author='anybody')) # Add new comment for a second bug with a different hash! bug2 = None for b in run_results: if b.bugHash != bug.bugHash: bug2 = b comment3 = CommentData(author='anybody', message='Third msg') success = self._cc_client.addComment(bug2.reportId, comment3) self.assertTrue(success) logging.debug('Bug commented successfully') # There are two comments available for the first bug comments = self._cc_client.getComments(bug.reportId) self.assertEqual(len(comments), 2) for c in comments: self.assertEqual(c.author, 'cc') num_comment = self._cc_client.getCommentCount(bug.reportId) self.assertEqual(num_comment, 2) # Check the order of comments (first comment is the earliest) self.assertGreater(comments[0].createdAt, comments[1].createdAt) # Remove the first comment print("removing comment:" + str(comments[0].id)) success = self._cc_client.removeComment(comments[0].id) self.assertTrue(success) logging.debug('Comment removed successfully') # Remove the second comment as john should be unsuccessful print("removing comment:" + str(comments[1].id)) with self.assertRaises(RequestFailed): self._cc_client_john.removeComment(comments[1].id) logging.debug('Comment was removed by another user') comments = self._cc_client.getComments(bug.reportId) self.assertEqual(len(comments), 1) num_comment = self._cc_client.getCommentCount(bug.reportId) self.assertEqual(num_comment, 1) # Edit the message of the first remaining comment new_msg = 'New msg' success = self._cc_client.updateComment(comments[0].id, new_msg) self.assertTrue(success) logging.debug('Comment edited successfully') # Update comment with empty message. with self.assertRaises(RequestFailed): self._cc_client.updateComment(comments[0].id, ' ') john_msg = 'John cannot edit' with self.assertRaises(RequestFailed): self._cc_client_john.updateComment(comments[0].id, john_msg) logging.debug('Comment was edited by john') comments = self._cc_client.getComments(bug.reportId) user_comments, system_comments = separate_comments(comments) self.assertEqual(len(user_comments), 1) self.assertEqual(user_comments[0].message, new_msg) self.assertEqual(len(system_comments), 1) # Remove the last comment for the first bug success = self._cc_client.removeComment(user_comments[0].id) self.assertTrue(success) logging.debug('Comment removed successfully') comments = self._cc_client.getComments(bug.reportId) self.assertEqual(len(comments), 1) self.assertEqual(comments[0].kind, CommentKind.SYSTEM) num_comment = self._cc_client.getCommentCount(bug.reportId) self.assertEqual(num_comment, 1) # Remove the last comment for the second bug. comments = self._cc_client.getComments(bug2.reportId) self.assertEqual(len(comments), 1) success = self._cc_client.removeComment(comments[0].id) self.assertTrue(success) logging.debug('Comment removed successfully') comments = self._cc_client.getComments(bug2.reportId) self.assertEqual(len(comments), 0) num_comment = self._cc_client.getCommentCount(bug2.reportId) self.assertEqual(num_comment, 0)
def test_suppress_comment_in_db(self): """ Exported source suppress comment stored as a review status in the db. """ runid = self._runid logging.debug("Get all run results from the db for runid: " + str(runid)) hash_to_suppress_msgs = {} with open(os.path.join(self._test_project_path, "suppress.expected"), 'r', encoding="utf-8", errors="ignore") as expected: for line in expected: src_code_info = line.strip().split('||') status = None if len(src_code_info) == 4: # Newest source code comment format where status is given. bug_hash, _, msg, status = src_code_info elif len(src_code_info) == 3: # Old format where review status is not given. bug_hash, _, msg = src_code_info else: # Oldest source code comment format where status and file # name are not given. bug_hash, msg = src_code_info rw_status = ReviewStatus.FALSE_POSITIVE if status == 'confirmed': rw_status = ReviewStatus.CONFIRMED elif status == 'intentional': rw_status = ReviewStatus.INTENTIONAL hash_to_suppress_msgs[bug_hash] = {'message': msg, 'status': rw_status} run_results = get_all_run_results(self._cc_client, runid) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) for bug_hash in hash_to_suppress_msgs: expected = hash_to_suppress_msgs[bug_hash] report = [x for x in run_results if x.bugHash == bug_hash][0] # Check the stored suppress comment self.assertEqual(report.reviewData.comment, expected['message']) self.assertEqual(report.reviewData.status, expected['status']) # Change review status to confirmed bug. review_comment = "This is really a bug" status = ReviewStatus.CONFIRMED success = self._cc_client.changeReviewStatus( report.reportId, status, review_comment) self.assertTrue(success) logging.debug("Bug review status changed successfully") # Get the results to compare. updated_results = get_all_run_results(self._cc_client, self._runid) self.assertIsNotNone(updated_results) self.assertNotEqual(len(updated_results), 0) for bug_hash in hash_to_suppress_msgs: report = [x for x in updated_results if x.bugHash == bug_hash][0] # Check the stored suppress comment self.assertEqual(report.reviewData.comment, "This is really a bug") self.assertEqual(report.reviewData.status, ReviewStatus.CONFIRMED) # Check the same project again. codechecker_cfg = env.import_test_cfg( self._test_workspace)['codechecker_cfg'] initial_test_project_name = self._run_name ret = codechecker.check_and_store(codechecker_cfg, initial_test_project_name, self._test_project_path) if ret: sys.exit(1) # Get the results to compare. updated_results = get_all_run_results(self._cc_client, self._runid) self.assertIsNotNone(updated_results) self.assertNotEqual(len(updated_results), 0) for bug_hash in hash_to_suppress_msgs: expected = hash_to_suppress_msgs[bug_hash] report = [x for x in updated_results if x.bugHash == bug_hash][0] # Check that source code comments in the database are changed back # after storage. self.assertEqual(report.reviewData.comment, expected['message']) self.assertEqual(report.reviewData.status, expected['status'])
def test_multiple_change_review_status(self): """ Test changing review status of the same bug. """ runid = self._runid logging.debug('Get all run results from the db for runid: ' + str(runid)) run_results = get_all_run_results(self._cc_client, runid) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) bug = run_results[0] # Change review status to confirmed bug. review_comment = 'This is really a bug' status = ReviewStatus.CONFIRMED success = self._cc_client.changeReviewStatus(bug.reportId, status, review_comment) self.assertTrue(success) logging.debug('Bug review status changed successfully') report = self._cc_client.getReport(bug.reportId) self.assertEqual(report.reviewData.comment, review_comment) self.assertEqual(report.reviewData.status, status) # Try to change review status back to unreviewed. status = ReviewStatus.UNREVIEWED success = self._cc_client.changeReviewStatus(bug.reportId, status, u'') self.assertTrue(success) logging.debug("Bug review status changed successfully") report = self._cc_client.getReport(bug.reportId) self.assertEqual(report.reviewData.comment, '') self.assertEqual(report.reviewData.status, status) # Change review status to false positive. review_comment = 'This is not a bug' status = ReviewStatus.FALSE_POSITIVE success = self._cc_client.changeReviewStatus(bug.reportId, status, review_comment) self.assertTrue(success) logging.debug('Bug review status changed successfully') report = self._cc_client.getReport(bug.reportId) self.assertEqual(report.reviewData.comment, review_comment) self.assertEqual(report.reviewData.status, status) # Change review status to intentional. review_comment = u'' status = ReviewStatus.INTENTIONAL success = self._cc_client.changeReviewStatus(bug.reportId, status, review_comment) self.assertTrue(success) logging.debug('Bug review status changed successfully') report = self._cc_client.getReport(bug.reportId) self.assertEqual(report.reviewData.comment, review_comment) self.assertEqual(report.reviewData.status, status)
def test_export_import(self): """ Test exporting and importing feature """ run_filter = RunFilter() run_filter.names = [self.test_runs[0].name] logging.debug('Get all run results from the db for runid: ' + str(self.test_runs[0].runId)) run_results = get_all_run_results(self._cc_client, self.test_runs[0].runId) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) bug = run_results[0] # There are no comments available for the first bug comments = self._cc_client.getComments(bug.reportId) self.assertEqual(len(comments), 0) comment1 = CommentData(author='anybody', message='First msg') success = self._cc_client.addComment(bug.reportId, comment1) self.assertTrue(success) logging.debug('Bug commented successfully') # Try to add another new comment for the first bug comment2 = CommentData(author='anybody', message='Second msg') success = self._cc_client.addComment(bug.reportId, comment2) self.assertTrue(success) logging.debug('Bug commented successfully') # Change review status review_comment = 'This is really a bug' status = ReviewStatus.CONFIRMED success = self._cc_client.changeReviewStatus(bug.reportId, status, review_comment) self.assertTrue(success) logging.debug('Bug review status changed successfully') # Export the comments and reviews exported = self._cc_client.exportData(run_filter) exported_comments = exported.comments[bug.bugHash] exported_review = exported.reviewData[bug.bugHash] # Check if the comments are same user_comments = get_user_comments(exported_comments) self.assertEqual(user_comments[0].message, comment2.message) self.assertEqual(user_comments[1].message, comment1.message) # Check for the review status self.assertEqual(exported_review.status, status) self.assertEqual(exported_review.comment, review_comment) new_export_command = [ self._codechecker_cmd, 'cmd', 'export', '-n', self.test_runs[0].name, '--url', str(self.server_url) ] print(new_export_command) out_json = subprocess.check_output(new_export_command, encoding="utf-8", errors="ignore") resolved_results = json.loads(out_json) print(resolved_results) with tempfile.NamedTemporaryFile() as component_f: component_f.write(out_json.encode('utf-8')) component_f.flush() component_f.seek(0) self._cc_client.removeComment(user_comments[0].id) updated_message = "The new comment for testing" self._cc_client.updateComment(user_comments[1].id, updated_message) new_import_command = [ self._codechecker_cmd, 'cmd', 'import', '-i', component_f.name, '--url', str(self.server_url) ] print(new_import_command) subprocess.check_output(new_import_command, encoding="utf-8", errors="ignore") exported = self._cc_client.exportData(run_filter) new_comments = exported.comments[bug.bugHash] print(new_comments) # Check if the last and second last comments self.assertEqual(new_comments[-1].message, comment1.message) self.assertEqual(new_comments[-2].message, updated_message)
def test_assign_reports_to_cleanup_plans(self): """ Test assigning reports to cleanup plans. """ name = "Test" description = None due_date = None cleanup_plan_id = self._cc_client.addCleanupPlan( name, description, due_date) # Get all cleanup plans. cleanup_plans = self._cc_client.getCleanupPlans(None) self.assertEqual(len(cleanup_plans), 1) cleanup_plan = cleanup_plans[0] self.assertEqual(cleanup_plan.reportHashes, []) # Get results from the database. run_results = get_all_run_results(self._cc_client) self.assertTrue(run_results) uniqued_report_hashes = set(r.bugHash for r in run_results) self.assertTrue(len(uniqued_report_hashes) > 2) it = iter(uniqued_report_hashes) report_hash_1 = next(it) report_hash_2 = next(it) report_hashes = [report_hash_1, report_hash_2] # Assign report to cleanup. success = self._cc_client.setCleanupPlan( cleanup_plan_id, report_hashes) self.assertTrue(success) cleanup_plans = self._cc_client.getCleanupPlans(None) cleanup_plan = cleanup_plans[0] self.assertCountEqual( cleanup_plan.reportHashes, report_hashes) # Filter reports based on cleanup plan. report_filter = ReportFilter(cleanupPlanNames=[name]) run_results = get_all_run_results( self._cc_client, filters=report_filter) self.assertTrue(run_results) for report in run_results: self.assertTrue(report.bugHash in report_hashes, f"{report.bugHash} not found in cleanup plan.") # Remove report hash from cleanup plan. success = self._cc_client.unsetCleanupPlan( cleanup_plan_id, [report_hash_2]) self.assertTrue(success) cleanup_plans = self._cc_client.getCleanupPlans(None) cleanup_plan = cleanup_plans[0] self.assertCountEqual( cleanup_plan.reportHashes, [report_hash_1]) success = self._cc_client.unsetCleanupPlan( cleanup_plan_id, [report_hash_1]) self.assertTrue(success) cleanup_plans = self._cc_client.getCleanupPlans(None) cleanup_plan = cleanup_plans[0] self.assertFalse(cleanup_plan.reportHashes) # Remove cleanup. success = self._cc_client.removeCleanupPlan(cleanup_plan_id) self.assertTrue(success)
def test_multiple_change_review_status(self): """ Test changing review status of the same bug. """ runid = self._runid logging.debug('Get all run results from the db for runid: ' + str(runid)) run_results = get_all_run_results(self._cc_client, runid) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) bug = run_results[0] # There are no system comments for this bug. comments = self.__get_system_comments(bug.reportId) self.assertEqual(len(comments), 0) # Change review status to confirmed bug. review_comment = 'This is really a bug' status = ReviewStatus.CONFIRMED success = self._cc_client.changeReviewStatus(bug.reportId, status, review_comment) self.assertTrue(success) logging.debug('Bug review status changed successfully') report = self._cc_client.getReport(bug.reportId) self.assertEqual(report.reviewData.comment, review_comment) self.assertEqual(report.reviewData.status, status) # There is one system comment for this bug. comments = self.__get_system_comments(bug.reportId) self.assertEqual(len(comments), 1) # Try to update the review status again with the same data and check # that no new system comment entry will be created. success = self._cc_client.changeReviewStatus(bug.reportId, status, review_comment) comments = self.__get_system_comments(bug.reportId) self.assertEqual(len(comments), 1) # Test that updating only the review status message a new system # comment will be created. success = self._cc_client.changeReviewStatus( bug.reportId, status, "test system comment change") self.assertTrue(success) comments = self.__get_system_comments(bug.reportId) self.assertEqual(len(comments), 2) # Try to change review status back to unreviewed. status = ReviewStatus.UNREVIEWED success = self._cc_client.changeReviewStatus(bug.reportId, status, None) self.assertTrue(success) logging.debug("Bug review status changed successfully") report = self._cc_client.getReport(bug.reportId) self.assertEqual(report.reviewData.comment, '') self.assertEqual(report.reviewData.status, status) # Change review status to false positive. review_comment = 'This is not a bug' status = ReviewStatus.FALSE_POSITIVE success = self._cc_client.changeReviewStatus(bug.reportId, status, review_comment) self.assertTrue(success) logging.debug('Bug review status changed successfully') report = self._cc_client.getReport(bug.reportId) self.assertEqual(report.reviewData.comment, review_comment) self.assertEqual(report.reviewData.status, status) # Change review status to intentional. review_comment = '' status = ReviewStatus.INTENTIONAL success = self._cc_client.changeReviewStatus(bug.reportId, status, review_comment) self.assertTrue(success) logging.debug('Bug review status changed successfully') report = self._cc_client.getReport(bug.reportId) self.assertEqual(report.reviewData.comment, review_comment) self.assertEqual(report.reviewData.status, status)
def test_multiple_change_review_status(self): """ Test changing review status of the same bug. """ runid = self._runid logging.debug('Get all run results from the db for runid: ' + str(runid)) run_results = get_all_run_results(self._cc_client, runid) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) bug = run_results[0] # Change review status to confirmed bug. review_comment = 'This is really a bug' status = ReviewStatus.CONFIRMED success = self._cc_client.changeReviewStatus( bug.reportId, status, review_comment) self.assertTrue(success) logging.debug('Bug review status changed successfully') report = self._cc_client.getReport(bug.reportId) self.assertEqual(report.reviewData.comment, review_comment) self.assertEqual(report.reviewData.status, status) # Try to change review status back to unreviewed. status = ReviewStatus.UNREVIEWED success = self._cc_client.changeReviewStatus( bug.reportId, status, u'') self.assertTrue(success) logging.debug("Bug review status changed successfully") report = self._cc_client.getReport(bug.reportId) self.assertEqual(report.reviewData.comment, '') self.assertEqual(report.reviewData.status, status) # Change review status to false positive. review_comment = 'This is not a bug' status = ReviewStatus.FALSE_POSITIVE success = self._cc_client.changeReviewStatus( bug.reportId, status, review_comment) self.assertTrue(success) logging.debug('Bug review status changed successfully') report = self._cc_client.getReport(bug.reportId) self.assertEqual(report.reviewData.comment, review_comment) self.assertEqual(report.reviewData.status, status) # Change review status to intentional. review_comment = u'' status = ReviewStatus.INTENTIONAL success = self._cc_client.changeReviewStatus( bug.reportId, status, review_comment) self.assertTrue(success) logging.debug('Bug review status changed successfully') report = self._cc_client.getReport(bug.reportId) self.assertEqual(report.reviewData.comment, review_comment) self.assertEqual(report.reviewData.status, status)
def test_suppress_comment_in_db(self): """ Exported source suppress comment stored as a review status in the db. """ runid = self._runid logging.debug("Get all run results from the db for runid: " + str(runid)) hash_to_suppress_msgs = {} with open(os.path.join(self._test_project_path, "suppress.expected"), 'r') as expected: for line in expected: src_code_info = line.strip().split('||') status = None if len(src_code_info) == 4: # Newest source code comment format where status is given. bug_hash, _, msg, status = src_code_info elif len(src_code_info) == 3: # Old format where review status is not given. bug_hash, _, msg = src_code_info else: # Oldest source code comment format where status and file # name are not given. bug_hash, msg = src_code_info rw_status = ReviewStatus.FALSE_POSITIVE if status == 'confirmed': rw_status = ReviewStatus.CONFIRMED elif status == 'intentional': rw_status = ReviewStatus.INTENTIONAL hash_to_suppress_msgs[bug_hash] = {'message': msg, 'status': rw_status} run_results = get_all_run_results(self._cc_client, runid) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) for bug_hash in hash_to_suppress_msgs: expected = hash_to_suppress_msgs[bug_hash] report = [x for x in run_results if x.bugHash == bug_hash][0] # Check the stored suppress comment self.assertEqual(report.reviewData.comment, expected['message']) self.assertEqual(report.reviewData.status, expected['status']) # Change review status to confirmed bug. review_comment = "This is really a bug" status = ReviewStatus.CONFIRMED success = self._cc_client.changeReviewStatus( report.reportId, status, review_comment) self.assertTrue(success) logging.debug("Bug review status changed successfully") # Get the results to compare. updated_results = get_all_run_results(self._cc_client, self._runid) self.assertIsNotNone(updated_results) self.assertNotEqual(len(updated_results), 0) for bug_hash in hash_to_suppress_msgs: report = [x for x in updated_results if x.bugHash == bug_hash][0] # Check the stored suppress comment self.assertEqual(report.reviewData.comment, "This is really a bug") self.assertEqual(report.reviewData.status, ReviewStatus.CONFIRMED) # Check the same project again. codechecker_cfg = env.import_test_cfg( self._test_workspace)['codechecker_cfg'] initial_test_project_name = self._run_name ret = codechecker.check(codechecker_cfg, initial_test_project_name, self._test_project_path) if ret: sys.exit(1) # Get the results to compare. updated_results = get_all_run_results(self._cc_client, self._runid) self.assertIsNotNone(updated_results) self.assertNotEqual(len(updated_results), 0) for bug_hash in hash_to_suppress_msgs: expected = hash_to_suppress_msgs[bug_hash] report = [x for x in updated_results if x.bugHash == bug_hash][0] # Check that source code comments in the database are changed back # after storage. self.assertEqual(report.reviewData.comment, expected['message']) self.assertEqual(report.reviewData.status, expected['status'])
def test_comment(self): """ Test commenting of multiple bugs. """ runid = self._test_runs[0].runId logging.debug('Get all run results from the db for runid: ' + str(runid)) run_results = get_all_run_results(self._cc_client, runid) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) bug = run_results[0] # There are no comments available for the first bug comments = self._cc_client.getComments(bug.reportId) self.assertEqual(len(comments), 0) num_comment = self._cc_client.getCommentCount(bug.reportId) self.assertEqual(num_comment, 0) # Try to add a new comment for the first bug comment1 = CommentData(author='anybody', message='First msg') success = self._cc_client.addComment(bug.reportId, comment1) self.assertTrue(success) logging.debug('Bug commented successfully') # Try to add another new comment for the first bug comment2 = CommentData(author='anybody', message='Second msg') success = self._cc_client.addComment(bug.reportId, comment2) self.assertTrue(success) logging.debug('Bug commented successfully') # Add new comment for a second bug with a different hash! bug2 = None for b in run_results: if b.bugHash != bug.bugHash: bug2 = b comment3 = CommentData(author='anybody', message='Third msg') success = self._cc_client.addComment(bug2.reportId, comment3) self.assertTrue(success) logging.debug('Bug commented successfully') # There are two comments available for the first bug comments = self._cc_client.getComments(bug.reportId) self.assertEqual(len(comments), 2) for c in comments: self.assertEqual(c.author, 'cc') num_comment = self._cc_client.getCommentCount(bug.reportId) self.assertEqual(num_comment, 2) # Check the order of comments (first comment is the earliest) self.assertGreater(comments[0].createdAt, comments[1].createdAt) # Remove the first comment print("removing comment:"+str(comments[0].id)) success = self._cc_client.removeComment(comments[0].id) self.assertTrue(success) logging.debug('Comment removed successfully') # Remove the second comment as john should be unsuccessful print("removing comment:"+str(comments[1].id)) with self.assertRaises(RequestFailed): self._cc_client_john.removeComment(comments[1].id) logging.debug('Comment was removed by another user') comments = self._cc_client.getComments(bug.reportId) self.assertEqual(len(comments), 1) num_comment = self._cc_client.getCommentCount(bug.reportId) self.assertEqual(num_comment, 1) # Edit the message of the first remaining comment new_msg = 'New msg' success = self._cc_client.updateComment(comments[0].id, new_msg) self.assertTrue(success) logging.debug('Comment edited successfully') john_msg = 'John cannot edit' with self.assertRaises(RequestFailed): self._cc_client_john.updateComment(comments[0].id, john_msg) logging.debug('Comment was edited by john') comments = self._cc_client.getComments(bug.reportId) self.assertEqual(len(comments), 1) self.assertEqual(comments[0].message, new_msg) # Remove the last comment for the first bug success = self._cc_client.removeComment(comments[0].id) self.assertTrue(success) logging.debug('Comment removed successfully') comments = self._cc_client.getComments(bug.reportId) self.assertEqual(len(comments), 0) num_comment = self._cc_client.getCommentCount(bug.reportId) self.assertEqual(num_comment, 0) # Remove the last comment for the second bug. comments = self._cc_client.getComments(bug2.reportId) self.assertEqual(len(comments), 1) success = self._cc_client.removeComment(comments[0].id) self.assertTrue(success) logging.debug('Comment removed successfully') comments = self._cc_client.getComments(bug2.reportId) self.assertEqual(len(comments), 0) num_comment = self._cc_client.getCommentCount(bug2.reportId) self.assertEqual(num_comment, 0)