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 = self._cc_client.getAllRunResults(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 = self._cc_client\ .getAllRunResults(runid, [], 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 = self._cc_client\ .getAllRunResults(runid, [], simple_filters) self.assertIsNotNone(run_results_unsuppressed) self.assertEqual(len(run_results), len(run_results_unsuppressed))
def test_zzzzz_get_run_results_checker_msg_filter_suppressed(self): """ This test must be run for last, suppresses some results which potentially changes the result counts. """ runid = self._runid logging.debug('Get all run results from the db for runid: ' + str(runid)) simple_filters = [ReportFilter(suppressed=False)] run_results = get_all_run_results(self._cc_client, runid, filters=simple_filters) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) suppress_msg = r'My beautiful Unicode comment.' bug = run_results[0] success = self._cc_client.suppressBug([runid], bug.reportId, suppress_msg) self.assertTrue(success) logging.debug('Bug suppressed successfully') simple_filters = [ReportFilter(suppressed=True)] run_results = get_all_run_results(self._cc_client, runid, filters=simple_filters) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) filtered_run_results = filter( lambda result: (result.reportId == bug.reportId) and result.suppressed, run_results) self.assertEqual(len(filtered_run_results), 1) suppressed_bug = filtered_run_results[0] self.assertEqual(suppressed_bug.suppressComment, suppress_msg) success = self._cc_client.unSuppressBug([runid], suppressed_bug.reportId) self.assertTrue(success) logging.debug('Bug unsuppressed successfully') simple_filters = [ReportFilter(suppressed=False)] run_results = get_all_run_results(self._cc_client, runid, filters=simple_filters) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) filtered_run_results = filter( lambda result: (result.reportId == bug.reportId) and not result.suppressed, run_results) self.assertEqual(len(filtered_run_results), 1) logging.debug('Done.\n')
def test_get_run_results_checker_msg_filter_suppressed(self): runid = self._runid logging.debug('Get all run results from the db for runid: ' + str(runid)) simple_filters = [ReportFilter(suppressed=False)] run_results = self._cc_client.getRunResults(runid, 50, 0, [], simple_filters) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) suppress_msg = r'My beautiful Unicode comment.' bug = run_results[0] success = self._cc_client.suppressBug([runid], bug.reportId, suppress_msg) self.assertTrue(success) logging.debug('Bug suppressed successfully') simple_filters = [ReportFilter(suppressed=True)] run_results = self._cc_client.getRunResults(runid, 50, 0, [], simple_filters) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) filtered_run_results = filter( lambda result: (result.reportId == bug.reportId) and result.suppressed, run_results) self.assertEqual(len(filtered_run_results), 1) suppressed_bug = filtered_run_results[0] self.assertEqual(suppressed_bug.suppressComment, suppress_msg) success = self._cc_client.unSuppressBug([runid], suppressed_bug.reportId) self.assertTrue(success) logging.debug('Bug unsuppressed successfully') simple_filters = [ReportFilter(suppressed=False)] run_results = self._cc_client.getRunResults(runid, 50, 0, [], simple_filters) self.assertIsNotNone(run_results) self.assertNotEqual(len(run_results), 0) filtered_run_results = filter( lambda result: (result.reportId == bug.reportId) and not result.suppressed, run_results) self.assertEqual(len(filtered_run_results), 1) logging.debug('Done.\n')
def test_get_source_file_content(self): # also for testing Unicode support """ Get the stored source file content from the database and compare it with the original version, unicode encoding decoding is tested during the storage and retrieving the data. """ 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 = self._cc_client.getRunResults(runid, run_result_count, 0, [], 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_get_diff_res_types_unresolved_filter(self): """ Test diff result types for unresolved results with checker name filter on the api. """ base_run_id = self._base_runid new_run_id = self._new_runid diff_res_types_filter = self._testproject_data[ self._clang_to_test]['diff_res_types_filter'] for level in diff_res_types_filter: for checker_name, test_result_count in level.items(): simple_filters = [ReportFilter(checkerId=checker_name)] diff_res = \ self._cc_client.getDiffResultTypes(base_run_id, new_run_id, DiffType.UNRESOLVED, simple_filters) print("Test cfg - " + checker_name + " : " + str(test_result_count)) print("Analysis - " + diff_res[0].checkerId + " : " + str(diff_res[0].count)) # There should be only one for each checker name. self.assertEqual(len(diff_res), 1) self.assertEqual(test_result_count, diff_res[0].count) self.assertEqual(checker_name, diff_res[0].checkerId)
def test_get_diff_res_count_unresolved_filter(self): """ This test asumes nothing has been resolved between the two checker runs. The the same severity levels and numbers are used as in a simple filter test for only one run from the project config. """ base_run_id = self._base_runid new_run_id = self._new_runid # Severity levels used for filtering. filter_severity_levels = self._testproject_data[ self._clang_to_test]['filter_severity_levels'] for level in filter_severity_levels: for severity_level, test_result_count in level.items(): simple_filters = [] sev = get_severity_level(severity_level) simple_filter = ReportFilter(severity=sev) simple_filters.append(simple_filter) diff_result_count = self._cc_client.getDiffResultCount( base_run_id, new_run_id, DiffType.UNRESOLVED, simple_filters) self.assertEqual(test_result_count, diff_result_count)
def test_get_diff_res_types_unresolved_filter(self): """ test diff result types for unresolved results with checker name filter on the api """ runs = self._cc_client.getRunData() self.assertIsNotNone(runs) self.assertNotEqual(len(runs), 0) self.assertGreaterEqual(len(runs), 2) base_run_id = runs[0].runId new_run_id = runs[1].runId diff_res_types_filter = self._testproject_data['diff_res_types_filter'] for level in diff_res_types_filter: for checker_name, test_result_count in level.iteritems(): simple_filters = [] simple_filter = ReportFilter(checkerId=checker_name) simple_filters.append(simple_filter) diff_res = self._cc_client.getDiffResultTypes( base_run_id, new_run_id, DiffType.UNRESOLVED, simple_filters) # there should be only one for each checker name self.assertEqual(len(diff_res), 1) self.assertEqual(test_result_count, diff_res[0].count) self.assertEqual(checker_name, diff_res[0].checkerId)
def test_get_diff_res_count_unresolved_filter(self): """ This test asumes nothing has been resolved between the two checker runs The the same severity levels and numbers are used as in a simple filter test for only one run from the project config """ runs = self._cc_client.getRunData() self.assertIsNotNone(runs) self.assertNotEqual(len(runs), 0) self.assertGreaterEqual(len(runs), 2) base_run_id = runs[0].runId new_run_id = runs[1].runId # severity levels used for filtering filter_severity_levels = self._testproject_data[ 'filter_severity_levels'] for level in filter_severity_levels: for severity_level, test_result_count in level.iteritems(): simple_filters = [] sev = get_severity_level(severity_level) simple_filter = ReportFilter(severity=sev) simple_filters.append(simple_filter) diff_result_count = self._cc_client.getDiffResultCount( base_run_id, new_run_id, DiffType.UNRESOLVED, simple_filters) self.assertEqual(test_result_count, diff_result_count)
def test_get_diff_res_count_unresolved_filter(self): base_run_id = self._base_runid new_run_id = self._new_runid filter_severity_levels = [{ "MEDIUM": 1 }, { "LOW": 5 }, { "HIGH": 12 }, { "STYLE": 0 }, { "UNSPECIFIED": 0 }, { "CRITICAL": 0 }] for level in filter_severity_levels: for severity_level, test_result_count in level.items(): simple_filters = [] sev = get_severity_level(severity_level) simple_filter = ReportFilter(severity=sev) simple_filters.append(simple_filter) diff_result_count = self._cc_client.getDiffResultCount( base_run_id, new_run_id, DiffType.UNRESOLVED, simple_filters) self.assertEqual(test_result_count, diff_result_count)
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 = self._cc_client.getAllRunResults(runid, [], 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_checker_id(self): """ Filter by checker id. """ runid = self._runid severity_test_data = self._testproject_data[ self._clang_to_test]['filter_checker_id'] for level in severity_test_data: for checker_id_filter, test_result_count in level.items(): logging.debug('Checker id filter ' + checker_id_filter + ' test result count: ' + str(test_result_count)) sort_types = None simple_filters = [] simple_filter = ReportFilter(checkerId=checker_id_filter) simple_filters.append(simple_filter) print(simple_filters) run_result_count = self._cc_client.getRunResultCount( runid, simple_filters) run_results = [] run_results = self._cc_client.getRunResults( runid, 500, 0, sort_types, simple_filters) for r in run_results: print(r) print("") self.assertIsNotNone(run_results) self.assertEqual(test_result_count, len(run_results))
def test_filter_severity(self): """ Filter by severity levels.""" runid = self._runid severity_test_data = self._testproject_data[ self._clang_to_test]['filter_severity_levels'] for level in severity_test_data: for severity_level, test_result_count in level.items(): logging.debug('Severity level filter ' + severity_level + ' test result count: ' + str(test_result_count)) sort_types = None sev = get_severity_level(severity_level) simple_filters = [ReportFilter(severity=sev)] run_result_count = self._cc_client.getRunResultCount( runid, simple_filters) run_results = self._cc_client.getRunResults( runid, run_result_count, 0, sort_types, simple_filters) self.assertIsNotNone(run_results) self.assertEqual(test_result_count, len(run_results))
def test_filter_case_insensitive_file_path(self): """ Filter by file path case insensitive.""" runid = self._runid filter_test_data = self._testproject_data[ self._clang_to_test]['filter_filepath_case_insensitive'] for level in filter_test_data: for filepath_filter, test_result_count in level.items(): logging.debug('File path filter ' + filepath_filter + ' test result count: ' + str(test_result_count)) sort_types = None simple_filters = [ReportFilter(filepath=filepath_filter)] run_result_count = self._cc_client.getRunResultCount( runid, simple_filters) run_results = self._cc_client.getRunResults( runid, run_result_count, 0, sort_types, simple_filters) self.assertIsNotNone(run_results) self.assertEqual(test_result_count, len(run_results))
def test_filter_file_path(self): ''' Filter by checker id''' runid = self._runid severity_test_data = self._testproject_data['filter_filepath'] for level in severity_test_data: for filepath_filter, test_result_count in level.iteritems(): logging.debug('File path filter ' + filepath_filter + ' test result count: ' + str(test_result_count)) sort_types = None simple_filters = [] simple_filter = ReportFilter(filepath=filepath_filter) simple_filters.append(simple_filter) run_result_count = self._cc_client.getRunResultCount( runid, simple_filters) run_results = self._cc_client.getRunResults( runid, run_result_count, 0, sort_types, simple_filters) self.assertIsNotNone(run_results) self.assertEqual(test_result_count, len(run_results))