def setUp(self):
host = 'localhost'
port = int(os.environ['CC_TEST_VIEWER_PORT'])
uri = '/'
self._testproject_data = json.loads(os.environ['CC_TEST_PROJECT_INFO'])
self.assertIsNotNone(self._testproject_data)
self._cc_client = CCViewerHelper(host, port, uri)
class RunResults(unittest.TestCase):
_ccClient = None
# selected runid for running the tests
_runid = None
def setUp(self):
host = 'localhost'
port = int(os.environ['CC_TEST_VIEWER_PORT'])
uri = '/'
self._testproject_data = json.loads(os.environ['CC_TEST_PROJECT_INFO'])
self.assertIsNotNone(self._testproject_data)
self._cc_client = CCViewerHelper(host, port, uri)
# -----------------------------------------------------
def test_suppress_file_set_in_cmd(self):
"""
server is started with a suppress file
check if the api returns a non empty string
tempfile is used for suppress file so name will change for each run
"""
self.assertNotEquals(self._cc_client.getSuppressFile(),
'')
def setUp(self):
host = 'localhost'
port = int(os.environ['CC_TEST_VIEWER_PORT'])
uri = '/'
self._testproject_data = json.loads(os.environ['CC_TEST_PROJECT_INFO'])
self.assertIsNotNone(self._testproject_data)
self._cc_client = CCViewerHelper(host, port, uri)
def setUp(self):
host = "localhost"
port = int(os.environ["CC_TEST_VIEWER_PORT"])
uri = "/"
self._testproject_data = json.loads(os.environ["CC_TEST_PROJECT_INFO"])
self.assertIsNotNone(self._testproject_data)
self._cc_client = CCViewerHelper(host, port, uri)
self._runid = self._select_one_runid()
class RunResults(unittest.TestCase):
_ccClient = None
# selected runid for running the tests
_runid = None
def setUp(self):
host = 'localhost'
port = int(os.environ['CC_TEST_VIEWER_PORT'])
uri = '/'
self._testproject_data = json.loads(os.environ['CC_TEST_PROJECT_INFO'])
self.assertIsNotNone(self._testproject_data)
self._cc_client = CCViewerHelper(host, port, uri)
# -----------------------------------------------------
def test_suppress_file_set_in_cmd(self):
"""
server is started with a suppress file
check if the api returns a non empty string
tempfile is used for suppress file so name will change for each run
"""
self.assertNotEquals(self._cc_client.getSuppressFile(), '')
def main():
# handle argument parsing
parseArgs()
#--- main part -------------------------------------------------------------
reportTimeList = []
getTimeList = []
with CCReportHelper(args.address, args.check_port) as ccReporter, \
CCViewerHelper(args.address, args.view_port, '/') as ccViewer, \
open(args.output, 'r+') as outFile:
outFile.truncate()
for runCount in range(runNumber):
before = datetime.datetime.now()
run_id = ccReporter.addCheckerRun(
'command', 'name_' + str(runCount) + '_' + str(uuid4()),
'version', False)
report_ids = []
for fileCount in range(fileNumber):
print('\nrun: ' + str(runCount + 1) + '/' + str(runNumber) +
'\nfile: ' + str(fileCount + 1) + '/' + str(fileNumber))
file_id = ccReporter.needFileContent(run_id, 'file_' +
str(fileCount)).fileId
ccReporter.addFileContent(file_id, fileContent)
build_action_id = ccReporter.addBuildAction(
run_id, 'build_cmd_' + str(fileCount),
'check_cmd_' + str(fileCount), 'target_' + str(fileCount))
ccReporter.finishBuildAction(build_action_id, '')
for bugCount in range(bugPerFile):
bug_pathes = []
bug_events = []
for bugElementCount in range(bugLength):
line = bugCount * bugLength + bugElementCount + 1
bug_pathes.append(
BugPathPos(line, 1, line, 10, file_id))
bug_events.append(
BugPathEvent(line, 1, line, 10, 'event_msg',
file_id))
report_id = ccReporter.addReport(
build_action_id, file_id, 'hash_' + str(run_id) + '_' +
str(fileCount) + '_' + str(bugCount), 1,
'checker_message', bug_pathes, bug_events,
'checker_name', 'checker_cat', 'bug_type', 1)
report_ids.append(report_id)
#ccReporter.moduleToReport(run_id, 'module_id', report_ids)
ccReporter.finishCheckerRun(run_id)
after = datetime.datetime.now()
time = (after - before).total_seconds()
reportTimeList.append(time)
before = datetime.datetime.now()
runIDs = [rundata.runId for rundata in ccViewer.getRunData()]
after = datetime.datetime.now()
time = (after - before).total_seconds()
getTimeList.append(time)
before = datetime.datetime.now()
res = ccViewer.getAllRunResults(runIDs[-1])
after = datetime.datetime.now()
time = (after - before).total_seconds()
getTimeList.append(time)
before = datetime.datetime.now()
reportData = ccViewer.getReportDetails(res[-1].reportId)
after = datetime.datetime.now()
time = (after - before).total_seconds()
getTimeList.append(time)
s = str(runCount) + ';' + str(reportTimeList[-1]) + ';' + str(
getTimeList[-3]) + ';' + str(getTimeList[-2]) + ';' + str(
getTimeList[-1])
print(s)
outFile.write(s + '\n')
class RunResults(unittest.TestCase):
_ccClient = None
# selected runid for running the tests
_runid = None
def _select_one_runid(self):
runs = self._cc_client.getRunData()
self.assertIsNotNone(runs)
self.assertNotEqual(len(runs), 0)
# select one random run
idx = 0
return runs[idx].runId
def setUp(self):
host = 'localhost'
port = int(os.environ['CC_TEST_VIEWER_PORT'])
uri = '/'
self._testproject_data = json.loads(os.environ['CC_TEST_PROJECT_INFO'])
self.assertIsNotNone(self._testproject_data)
self._cc_client = CCViewerHelper(host, port, uri)
self._runid = self._select_one_runid()
# -----------------------------------------------------
def test_get_run_results_no_filter(self):
runid = self._runid
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 = self._cc_client.getRunResults(runid, run_result_count, 0,
[], [])
self.assertIsNotNone(run_results)
self.assertEqual(run_result_count, len(run_results))
for run_res in run_results:
debug('{0:15s} {1}'.format(run_res.checkedFile,
run_res.checkerId))
debug('{0:15d} {1}'.format(run_res.reportId, run_res.suppressed))
debug(run_res.lastBugPosition)
debug('-------------------------------------------------')
debug('got ' + str(len(run_results)) + ' reports')
debug('Done.\n')
# -----------------------------------------------------
def test_get_run_results_checker_id_and_file_path(self):
runid = self._runid
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 = self._cc_client.getRunResults(runid, run_result_count, 0,
[], [])
self.assertIsNotNone(run_results)
self.assertEqual(run_result_count, len(run_results))
found_all = True
for bug in self._testproject_data['bugs']:
found = False
for run_res in run_results:
found |= (run_res.checkedFile.endswith(bug['file'])) and \
(run_res.lastBugPosition.startLine == bug['line']) and \
(run_res.checkerId == bug['checker']) and \
(run_res.bugHash == bug['hash'])
found_all &= found
self.assertTrue(found_all)
for run_res in run_results:
debug('{0:15s} {1}'.format(run_res.checkedFile,
run_res.checkerId))
debug('reportId: {0} suppressed: {1}'.format(
run_res.reportId, run_res.suppressed))
debug(run_res.lastBugPosition)
debug('-------------------------------------------------')
debug('got ' + str(len(run_results)) + ' reports')
# -----------------------------------------------------
def test_get_source_file_content(self): # also for testing Unicode support
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)
self.assertEqual(run_result_count, len(run_results))
for run_res in run_results:
self.assertTrue(re.match(r'.*\.c(pp)?$', run_res.checkedFile))
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)
debug('got ' + str(len(run_results)) + ' files')
# -----------------------------------------------------
def test_zzzzz_get_run_results_checker_msg_filter_suppressed(self):
# this function must be run for last
runid = self._runid
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)
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)
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)
debug('Done.\n')
# -----------------------------------------------------
def test_get_run_results_severity_sort(self):
runid = self._runid
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 = self._cc_client.getRunResults(runid, run_result_count, 0,
sort_types, [])
self.assertIsNotNone(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.severity <= bug2.severity)
self.assertTrue((bug1.severity != bug2.severity)
or (bug1.checkedFile <= bug2.checkedFile))
for run_res in run_results:
debug('{0:15s} {1}'.format(run_res.checkedFile,
run_res.checkerId))
debug('{0:15d} {1}'.format(run_res.reportId, run_res.suppressed))
debug(run_res.lastBugPosition)
debug('-------------------------------------------------')
debug('got ' + str(len(run_results)) + ' reports')
debug('Done.\n')
# -----------------------------------------------------
def test_get_run_results_sorted2(self):
runid = self._runid
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 = self._cc_client.getRunResults(runid, run_result_count, 0,
sort_types, [])
self.assertIsNotNone(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))
for run_res in run_results:
debug('{0:15s} {1}'.format(run_res.checkedFile,
run_res.checkerId))
debug('{0:15d} {1}'.format(run_res.reportId, run_res.suppressed))
debug(run_res.lastBugPosition)
debug('-------------------------------------------------')
debug('got ' + str(len(run_results)) + ' reports')
debug('Done.\n')
class RunResults(unittest.TestCase):
_ccClient = None
# selected runid for running the tests
_runid = None
def _select_one_runid(self):
runs = self._cc_client.getRunData()
self.assertIsNotNone(runs)
self.assertNotEqual(len(runs), 0)
# select one random run
idx = random.randint(0, len(runs) - 1)
return runs[idx].runId
def setUp(self):
host = 'localhost'
port = int(os.environ['CC_TEST_VIEWER_PORT'])
uri = '/'
self._testproject_data = json.loads(os.environ['CC_TEST_PROJECT_INFO'])
self.assertIsNotNone(self._testproject_data)
self._cc_client = CCViewerHelper(host, port, uri)
self._runid = self._select_one_runid()
# -----------------------------------------------------
def test_get_run_results_no_filter(self):
runid = self._runid
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 = self._cc_client.getRunResults(runid, run_result_count,
0, [], [])
self.assertIsNotNone(run_results)
self.assertEqual(run_result_count, len(run_results))
for run_res in run_results:
debug('{0:15s} {1}'.format(run_res.checkedFile, run_res.checkerId))
debug('{0:15d} {1}'.format(run_res.reportId, run_res.suppressed))
debug(run_res.lastBugPosition)
debug('-------------------------------------------------')
debug('got ' + str(len(run_results)) + ' reports')
debug('Done.\n')
# -----------------------------------------------------
def test_get_run_results_checker_id_and_file_path(self):
runid = self._runid
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 = self._cc_client.getRunResults(runid, run_result_count,
0, [], [])
self.assertIsNotNone(run_results)
self.assertEqual(run_result_count, len(run_results))
found_all = True
for bug in self._testproject_data['bugs']:
found = False
for run_res in run_results:
found |= (run_res.checkedFile.endswith(bug['file'])) and \
(run_res.lastBugPosition.startLine == bug['line']) and \
(run_res.checkerId == bug['checker']) and \
(run_res.bugHash == bug['hash'])
found_all &= found
self.assertTrue(found_all)
for run_res in run_results:
debug('{0:15s} {1}'.format(run_res.checkedFile, run_res.checkerId))
debug('reportId: {0} suppressed: {1}'.format(run_res.reportId,
run_res.suppressed))
debug(run_res.lastBugPosition)
debug('-------------------------------------------------')
debug('got ' + str(len(run_results)) + ' reports')
# -----------------------------------------------------
def test_get_source_file_content(self): # also for testing Unicode support
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)
self.assertEqual(run_result_count, len(run_results))
for run_res in run_results:
self.assertTrue(re.match(r'.*\.c(pp)?$', run_res.checkedFile))
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)
debug('got ' + str(len(run_results)) + ' files')
# -----------------------------------------------------
def test_zzzzz_get_run_results_checker_msg_filter_suppressed(self):
# this function must be run for last
runid = self._runid
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)
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)
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)
debug('Done.\n')
# -----------------------------------------------------
def test_get_run_results_severity_sort(self):
runid = self._runid
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 = self._cc_client.getRunResults(runid, run_result_count,
0, sort_types, [])
self.assertIsNotNone(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.severity <= bug2.severity)
self.assertTrue((bug1.severity != bug2.severity) or
(bug1.checkedFile <= bug2.checkedFile))
for run_res in run_results:
debug('{0:15s} {1}'.format(run_res.checkedFile, run_res.checkerId))
debug('{0:15d} {1}'.format(run_res.reportId, run_res.suppressed))
debug(run_res.lastBugPosition)
debug('-------------------------------------------------')
debug('got ' + str(len(run_results)) + ' reports')
debug('Done.\n')
# -----------------------------------------------------
def test_get_run_results_sorted2(self):
runid = self._runid
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 = self._cc_client.getRunResults(runid, run_result_count, 0,
sort_types, [])
self.assertIsNotNone(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.checkerId <= bug2.checkerId))
for run_res in run_results:
debug('{0:15s} {1}'.format(run_res.checkedFile, run_res.checkerId))
debug('{0:15d} {1}'.format(run_res.reportId, run_res.suppressed))
debug(run_res.lastBugPosition)
debug('-------------------------------------------------')
debug('got ' + str(len(run_results)) + ' reports')
debug('Done.\n')
class RunResults(unittest.TestCase):
_ccClient = None
# selected runid for running the tests
_runid = None
def _select_one_runid(self):
runs = self._cc_client.getRunData()
self.assertIsNotNone(runs)
self.assertNotEqual(len(runs), 0)
# select one random run
idx = random.randint(0, len(runs) - 1)
return runs[idx].runId
def setUp(self):
host = 'localhost'
port = int(os.environ['CC_TEST_VIEWER_PORT'])
uri = '/'
self._testproject_data = json.loads(os.environ['CC_TEST_PROJECT_INFO'])
self.assertIsNotNone(self._testproject_data)
self._cc_client = CCViewerHelper(host, port, uri)
self._runid = self._select_one_runid()
# -----------------------------------------------------
def test_filter_none(self):
''' Filter value is None should return all results'''
runid = self._runid
sort_types = None
simple_filters = None
run_result_count = self._cc_client.getRunResultCount(runid,
simple_filters)
self.assertIsNotNone(run_result_count)
run_results = self._cc_client.getRunResults(runid, run_result_count, 0,
sort_types, simple_filters)
self.assertIsNotNone(run_results)
self.assertEqual(run_result_count, len(run_results))
# -----------------------------------------------------
def test_filter_empty(self):
''' Filter value is empty list should return all results'''
runid = self._runid
sort_types = None
simple_filters = []
run_result_count = self._cc_client.getRunResultCount(runid,
simple_filters)
self.assertIsNotNone(run_result_count)
run_results = self._cc_client.getRunResults(runid, run_result_count, 0,
sort_types, simple_filters)
self.assertIsNotNone(run_results)
self.assertEqual(run_result_count, len(run_results))
# -----------------------------------------------------
def test_filter_severity(self):
''' Filter by severity levels'''
runid = self._runid
severity_test_data = self._testproject_data['filter_severity_levels']
for level in severity_test_data:
for severity_level, test_result_count in level.iteritems():
info('Severity level filter ' + severity_level +
' test result count: ' + str(test_result_count))
sort_types = None
simple_filters = []
sev = get_severity_level(severity_level)
simple_filter = ReportFilter(severity=sev)
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))
# -----------------------------------------------------
def test_filter_checker_id(self):
''' Filter by checker id'''
runid = self._runid
severity_test_data = self._testproject_data['filter_checker_id']
for level in severity_test_data:
for checker_id_filter, test_result_count in level.iteritems():
info('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)
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():
info('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))
class RunResults(unittest.TestCase):
_ccClient = None
# selected runid for running the tests
_runid = None
def _select_one_runid(self):
runs = self._cc_client.getRunData()
self.assertIsNotNone(runs)
self.assertNotEqual(len(runs), 0)
# select one random run
idx = 0
return runs[idx].runId
def setUp(self):
host = 'localhost'
port = int(os.environ['CC_TEST_VIEWER_PORT'])
uri = '/'
self._testproject_data = json.loads(os.environ['CC_TEST_PROJECT_INFO'])
self.assertIsNotNone(self._testproject_data)
self._cc_client = CCViewerHelper(host, port, uri)
self._runid = self._select_one_runid()
# -----------------------------------------------------
def test_filter_none(self):
''' Filter value is None should return all results'''
runid = self._runid
sort_types = None
simple_filters = None
run_result_count = self._cc_client.getRunResultCount(
runid, simple_filters)
self.assertIsNotNone(run_result_count)
run_results = self._cc_client.getRunResults(runid, run_result_count, 0,
sort_types, simple_filters)
self.assertIsNotNone(run_results)
self.assertEqual(run_result_count, len(run_results))
# -----------------------------------------------------
def test_filter_empty(self):
''' Filter value is empty list should return all results'''
runid = self._runid
sort_types = None
simple_filters = []
run_result_count = self._cc_client.getRunResultCount(
runid, simple_filters)
self.assertIsNotNone(run_result_count)
run_results = self._cc_client.getRunResults(runid, run_result_count, 0,
sort_types, simple_filters)
self.assertIsNotNone(run_results)
self.assertEqual(run_result_count, len(run_results))
# -----------------------------------------------------
def test_filter_severity(self):
''' Filter by severity levels'''
runid = self._runid
severity_test_data = self._testproject_data['filter_severity_levels']
for level in severity_test_data:
for severity_level, test_result_count in level.iteritems():
info('Severity level filter ' + severity_level +
' test result count: ' + str(test_result_count))
sort_types = None
simple_filters = []
sev = get_severity_level(severity_level)
simple_filter = ReportFilter(severity=sev)
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))
# -----------------------------------------------------
def test_filter_checker_id(self):
''' Filter by checker id'''
runid = self._runid
severity_test_data = self._testproject_data['filter_checker_id']
for level in severity_test_data:
for checker_id_filter, test_result_count in level.iteritems():
info('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)
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():
info('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))
# -----------------------------------------------------
def test_filter_case_insensitive_file_path(self):
''' Filter by file path case insensitive'''
runid = self._runid
filter_test_data = self._testproject_data[
'filter_filepath_case_insensitive']
for level in filter_test_data:
for filepath_filter, test_result_count in level.iteritems():
info('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))
class RunResults(unittest.TestCase):
_ccClient = None
# selected runid for running the tests
_runid = None
def setUp(self):
host = "localhost"
port = int(os.environ["CC_TEST_VIEWER_PORT"])
uri = "/"
self._testproject_data = json.loads(os.environ["CC_TEST_PROJECT_INFO"])
self.assertIsNotNone(self._testproject_data)
self._cc_client = CCViewerHelper(host, port, uri)
# -----------------------------------------------------
def test_get_diff_res_count_new(self):
"""
count the new results with no filter
"""
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_type_new = DiffType.NEW
diff_res = self._cc_client.getDiffResultCount(base_run_id, new_run_id, DiffType.NEW, [])
self.assertEqual(diff_res, 0)
# -----------------------------------------------------
def test_get_diff_res_count_resolved(self):
"""
count the resolved results with no filter
"""
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 = self._cc_client.getDiffResultCount(base_run_id, new_run_id, DiffType.RESOLVED, [])
self.assertEqual(diff_res, 0)
# -----------------------------------------------------
def test_get_diff_res_count_unresolved(self):
"""
count the unresolved results with no filter
"""
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_type_unresolved = DiffType.UNRESOLVED
diff_res = self._cc_client.getDiffResultCount(base_run_id, new_run_id, DiffType.UNRESOLVED, [])
self.assertEqual(diff_res, 7)
# -----------------------------------------------------
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
severity_test_data = self._testproject_data["filter_severity_levels"]
for level in severity_test_data:
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_types_new(self):
"""
test diff result types for new results
"""
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 = self._cc_client.getDiffResultTypes(base_run_id, new_run_id, DiffType.NEW, [])
self.assertEqual(len(diff_res), 0)
# -----------------------------------------------------
def test_get_diff_res_types_resolved(self):
"""
test diff result types for resolved results
"""
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 = self._cc_client.getDiffResultTypes(base_run_id, new_run_id, DiffType.RESOLVED, [])
self.assertEqual(len(diff_res), 0)
# -----------------------------------------------------
def test_get_diff_res_types_unresolved(self):
"""
test diff result types for unresolved results with no 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 = self._cc_client.getDiffResultTypes(base_run_id, new_run_id, DiffType.UNRESOLVED, [])
severity_test_data = self._testproject_data["diff_res_types_filter"]
for level in severity_test_data:
for checker_name, test_result_count in level.iteritems():
diff_res = self._cc_client.getDiffResultTypes(base_run_id, new_run_id, DiffType.UNRESOLVED, [])
res = [r for r in diff_res if r.checkerId == checker_name]
# there should be only one result for each checker name
self.assertEqual(len(res), 1)
self.assertEqual(test_result_count, res[0].count)
self.assertEqual(checker_name, res[0].checkerId)
# -----------------------------------------------------
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
severity_test_data = self._testproject_data["diff_res_types_filter"]
for level in severity_test_data:
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)
class RunResults(unittest.TestCase):
_ccClient = None
# selected runid for running the tests
_runid = None
def _select_one_runid(self):
runs = self._cc_client.getRunData()
self.assertIsNotNone(runs)
self.assertNotEqual(len(runs), 0)
# select one random run
idx = 0
return runs[idx].runId
def setUp(self):
host = "localhost"
port = int(os.environ["CC_TEST_VIEWER_PORT"])
uri = "/"
self._testproject_data = json.loads(os.environ["CC_TEST_PROJECT_INFO"])
self.assertIsNotNone(self._testproject_data)
self._cc_client = CCViewerHelper(host, port, uri)
self._runid = self._select_one_runid()
# -----------------------------------------------------
def test_filter_none(self):
""" Filter value is None should return all results"""
runid = self._runid
sort_types = None
simple_filters = None
run_result_count = self._cc_client.getRunResultCount(runid, simple_filters)
self.assertIsNotNone(run_result_count)
run_results = self._cc_client.getRunResults(runid, run_result_count, 0, sort_types, simple_filters)
self.assertIsNotNone(run_results)
self.assertEqual(run_result_count, len(run_results))
# -----------------------------------------------------
def test_filter_empty(self):
""" Filter value is empty list should return all results"""
runid = self._runid
sort_types = None
simple_filters = []
run_result_count = self._cc_client.getRunResultCount(runid, simple_filters)
self.assertIsNotNone(run_result_count)
run_results = self._cc_client.getRunResults(runid, run_result_count, 0, sort_types, simple_filters)
self.assertIsNotNone(run_results)
self.assertEqual(run_result_count, len(run_results))
# -----------------------------------------------------
def test_filter_severity(self):
""" Filter by severity levels"""
runid = self._runid
severity_test_data = self._testproject_data["filter_severity_levels"]
for level in severity_test_data:
for severity_level, test_result_count in level.iteritems():
info("Severity level filter " + severity_level + " test result count: " + str(test_result_count))
sort_types = None
simple_filters = []
sev = get_severity_level(severity_level)
simple_filter = ReportFilter(severity=sev)
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))
# -----------------------------------------------------
def test_filter_checker_id(self):
""" Filter by checker id"""
runid = self._runid
severity_test_data = self._testproject_data["filter_checker_id"]
for level in severity_test_data:
for checker_id_filter, test_result_count in level.iteritems():
info("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)
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():
info("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))
# -----------------------------------------------------
def test_filter_case_insensitive_file_path(self):
""" Filter by file path case insensitive"""
runid = self._runid
filter_test_data = self._testproject_data["filter_filepath_case_insensitive"]
for level in filter_test_data:
for filepath_filter, test_result_count in level.iteritems():
info("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))
