def testShutdownRecordKeeping(self): """Test that one server's shutdown keeps the other records.""" # NOTE: Do NOT rename this method. It MUST come lexicographically # AFTER testServerStartSecondary, because we shut down a server started # by the aforementioned method. # Kill the second started server. EVENT_2.set() # Give the server some grace period to react to the kill command. time.sleep(5) test_cfg = env.import_test_cfg(self._test_workspace) codechecker_1 = test_cfg['codechecker_1'] codechecker_2 = test_cfg['codechecker_2'] instance_1 = [i for i in instance_manager.get_instances(self.home) if i['port'] == codechecker_1['viewer_port'] and i['workspace'] == self._test_workspace] instance_2 = [i for i in instance_manager.get_instances(self.home) if i['port'] == codechecker_2['viewer_port'] and i['workspace'] == self._test_workspace] self.assertNotEqual(instance_1, [], "The stopped server deleted another server's " "record from the instance list!") self.assertEqual(instance_2, [], "The stopped server did not disappear from the" " instance list.")
def setUp(self): """ WARNING!!! This is an example how to get the configurations needed by the tests. WARNING!!! """ # TEST_WORKSPACE is automatically set by test package __init__.py . test_workspace = os.environ['TEST_WORKSPACE'] test_class = self.__class__.__name__ print('Running ' + test_class + ' tests in ' + test_workspace) # Get the test configuration from the prepared int the test workspace. test_cfg = env.import_test_cfg(test_workspace) # Get the test project configuration from the prepared test workspace. self._testproject_data = env.setup_test_proj_cfg(test_workspace) self.assertIsNotNone(self._testproject_data) # Setup a viewer client to test viewer API calls. self._cc_client = env.setup_viewer_client(test_workspace) self.assertIsNotNone(self._cc_client) # Get the CodeChecker cmd if needed for the tests. self._codechecker_cmd = env.codechecker_cmd() # Get the run names which belong to this test. run_names = env.get_run_names(test_workspace) runs = self._cc_client.getRunData(None) test_runs = [run for run in runs if run.name in run_names]
def test_suppress_import(self): """ Test the suppress file importing. """ generated_file = os.path.join(self._test_workspace, "generated.suppress") extract_cmd = ['CodeChecker', 'parse', os.path.join(self._test_workspace, "reports"), "--suppress", generated_file, "--export-source-suppress" ] ret = call_cmd(extract_cmd, self._test_project_path, env.test_env(self._test_workspace)) self.assertEqual(ret, 0, "Failed to generate suppress file.") codechecker_cfg = env.import_test_cfg( self._test_workspace)['codechecker_cfg'] product_url = env.parts_to_url(codechecker_cfg) import_cmd = ['CodeChecker', 'cmd', 'suppress', '-i', generated_file, '--url', product_url, self._run_name] print(import_cmd) ret = call_cmd(import_cmd, self._test_project_path, env.test_env(self._test_workspace)) self.assertEqual(ret, 0, "Failed to import suppress file.")
def testShutdownTerminateStopAll(self): """Tests that --stop-all kills all servers on the host.""" # NOTE: Yet again keep the lexicographical flow, no renames! test_cfg = env.import_test_cfg(self._test_workspace) codechecker_1 = test_cfg['codechecker_1'] codechecker_2 = test_cfg['codechecker_2'] EVENT_1.clear() EVENT_2.clear() start_server(codechecker_1, EVENT_1, ['--skip-db-cleanup']) start_server(codechecker_2, EVENT_2, ['--skip-db-cleanup']) self.assertEqual(len(instance_manager.get_instances(self.home)), 2, "Two servers were started but they don't appear " "in the instance list.") # Kill the servers via cmdline. self.assertEqual(0, self.run_cmd([env.codechecker_cmd(), 'server', '--stop-all']), "The stop-all command didn't return exit code 0.") self.assertEqual(len(instance_manager.get_instances(self.home)), 0, "Both servers were allegedly stopped but they " "did not disappear.")
def testServerStartSecondary(self): """Another started server appends itself to instance list.""" test_cfg = env.import_test_cfg(self._test_workspace) codechecker_1 = test_cfg['codechecker_1'] codechecker_2 = test_cfg['codechecker_2'] EVENT_2.clear() start_server(codechecker_2, EVENT_2, ['--skip-db-cleanup']) # Workspaces must match, servers were started in the same workspace. instance_workspaces = [ i['workspace'] for i in instance_manager.get_instances(self.home) if i['workspace'] == self._test_workspace] self.assertEqual(len(instance_workspaces), 2, "Two servers in the same workspace but the workspace" " was not found twice in the instance list.") # Exactly one server should own each port generated instance_ports = [ i['port'] for i in instance_manager.get_instances(self.home) if i['port'] == codechecker_1['viewer_port'] or i['port'] == codechecker_2['viewer_port']] self.assertEqual(len(instance_ports), 2, "The ports for the two started servers were not found" " in the instance list.")
def setUp(self): # Get the test workspace used to authentication tests. self._test_workspace = os.environ['TEST_WORKSPACE'] test_class = self.__class__.__name__ print('Running ' + test_class + ' tests in ' + self._test_workspace) self._test_cfg = env.import_test_cfg(self._test_workspace)
def setUp(self): # Get the test workspace used to tests. self._test_workspace = os.environ['TEST_WORKSPACE'] test_cfg = env.import_test_cfg(self._test_workspace) self._test_env = test_cfg['codechecker_1']['check_env'] self.home = self._test_env['HOME'] test_class = self.__class__.__name__ print('Running ' + test_class + ' tests in ' + self._test_workspace)
def teardown_package(): """Clean up after the test.""" # TODO: If environment variable is set keep the workspace # and print out the path. global TEST_WORKSPACE check_env = env.import_test_cfg(TEST_WORKSPACE)[ 'codechecker_cfg']['check_env'] codechecker.remove_test_package_product(TEST_WORKSPACE, check_env) print("Removing: " + TEST_WORKSPACE)
def setUp(self): # TEST_WORKSPACE is automatically set by test package __init__.py . test_workspace = os.environ['TEST_WORKSPACE'] test_class = self.__class__.__name__ print('Running ' + test_class + ' tests in ' + test_workspace) codechecker_cfg = env.import_test_cfg(test_workspace)[ 'codechecker_cfg'] self.server_url = env.parts_to_url(codechecker_cfg) # Get the test project configuration from the prepared test workspace. self._testproject_data = env.setup_test_proj_cfg(test_workspace) self.assertIsNotNone(self._testproject_data) # Setup a viewer client to test viewer API calls. self._cc_client = env.setup_viewer_client(test_workspace) self.assertIsNotNone(self._cc_client) # Get the CodeChecker cmd if needed for the tests. self._codechecker_cmd = env.codechecker_cmd() self._test_config = env.import_test_cfg(test_workspace)
def teardown_package(): """Stop the CodeChecker server and clean up after the tests.""" # TODO If environment variable is set keep the workspace # and print out the path. global TEST_WORKSPACE # Removing the product through this server requires credentials. codechecker_cfg = env.import_test_cfg(TEST_WORKSPACE)['codechecker_cfg'] codechecker.remove_test_package_product(TEST_WORKSPACE, codechecker_cfg['check_env']) __STOP_SERVER.set() print("Removing: " + TEST_WORKSPACE) shutil.rmtree(TEST_WORKSPACE, ignore_errors=True)
def testServerStart(self): """Started server writes itself to instance list.""" test_cfg = env.import_test_cfg(self._test_workspace) codechecker_1 = test_cfg['codechecker_1'] EVENT_1.clear() start_server(codechecker_1, EVENT_1, ['--skip-db-cleanup']) instance = [i for i in instance_manager.get_instances(self.home) if i['port'] == codechecker_1['viewer_port'] and i['workspace'] == self._test_workspace] self.assertNotEqual(instance, [], "The started server did not register itself to the" " instance list.")
def teardown_package(): """Stop the CodeChecker server and clean up after the tests.""" # TODO If environment variable is set keep the workspace # and print out the path. global TEST_WORKSPACE check_env = env.import_test_cfg(TEST_WORKSPACE)[ 'codechecker_cfg']['check_env'] codechecker.remove_test_package_product(TEST_WORKSPACE, check_env) # Let the remaining CodeChecker servers die. EVENT_1.set() print("Removing: " + TEST_WORKSPACE) shutil.rmtree(TEST_WORKSPACE, ignore_errors=True)
def setUp(self): """ """ # TEST_WORKSPACE is automatically set by test package __init__.py . self.test_workspace = os.environ['TEST_WORKSPACE'] test_class = self.__class__.__name__ print('Running ' + test_class + ' tests in ' + self.test_workspace) # Get the test configuration from the prepared int the test workspace. self.test_cfg = env.import_test_cfg(self.test_workspace) self.product_name = self.test_cfg['codechecker_cfg']['viewer_product'] # Setup a viewer client to test viewer API calls. self._cc_client = env.setup_viewer_client(self.test_workspace) self.assertIsNotNone(self._cc_client) # Setup an authentication client for creating sessions. self._auth_client = env.setup_auth_client(self.test_workspace, session_token='_PROHIBIT') # Create a SUPERUSER login. root_token = self._auth_client.performLogin("Username:Password", "root:root") # Setup a product client to test product API calls. self._pr_client = env.setup_product_client(self.test_workspace) self.assertIsNotNone(self._pr_client) # Setup a product client to test product API calls which requires root. self._root_client = env.setup_product_client(self.test_workspace, session_token=root_token) self.assertIsNotNone(self._pr_client) # Get the run names which belong to this test. run_names = env.get_run_names(self.test_workspace) runs = self._cc_client.getRunData(None) test_runs = [run for run in runs if run.name in run_names] self.assertEqual(len(test_runs), 1, "There should be only one run for this test.") self._runid = test_runs[0].runId
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 setUp(self): test_workspace = os.environ['TEST_WORKSPACE'] test_class = self.__class__.__name__ print('Running ' + test_class + ' tests in ' + test_workspace) # Get the clang version which is tested. self._clang_to_test = env.clang_to_test() self._testproject_data = env.setup_test_proj_cfg(test_workspace) self.assertIsNotNone(self._testproject_data) self._cc_client = env.setup_viewer_client(test_workspace) self.assertIsNotNone(self._cc_client) # Get the run names which belong to this test. run_names = env.get_run_names(test_workspace) runs = self._cc_client.getRunData(None) test_runs = [run for run in runs if run.name in run_names] for r in test_runs: print(r) # There should be at least two runs for this test. self.assertIsNotNone(runs) self.assertNotEqual(len(runs), 0) self.assertGreaterEqual(len(runs), 2) # Name order matters from __init__ ! self._base_runid = test_runs[0].runId # base self._new_runid = test_runs[1].runId # new self._update_runid = test_runs[2].runId # updated self._codechecker_cmd = env.codechecker_cmd() self._report_dir = os.path.join(test_workspace, "reports") self._report_dir_baseline = os.path.join(test_workspace, "reports_baseline") self._test_config = env.import_test_cfg(test_workspace) self._run_names = env.get_run_names(test_workspace) self._html_reports = os.path.join(test_workspace, "html_reports") self._url = env.parts_to_url(self._test_config['codechecker_cfg'])
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 setUp(self): """ Set up the environment and the test module's configuration from the package. """ # TEST_WORKSPACE is automatically set by test package __init__.py . self.test_workspace_main = os.environ['TEST_WORKSPACE'] test_class = self.__class__.__name__ print('Running ' + test_class + ' tests in ' + self.test_workspace_main) # Set up a configuration for the main server. # Get the test configuration from the prepared int the test workspace. self.test_cfg = env.import_test_cfg(self.test_workspace_main) self.product_name = self.test_cfg['codechecker_cfg']['viewer_product'] # Setup a viewer client to test viewer API calls. self._cc_client = env.setup_viewer_client(self.test_workspace_main) self.assertIsNotNone(self._cc_client) # Setup an authentication client for creating sessions. self._auth_client = env.setup_auth_client(self.test_workspace_main, session_token='_PROHIBIT') # Create a SUPERUSER login. root_token = self._auth_client.performLogin("Username:Password", "root:root") ret = self._auth_client.addPermission(Permission.SUPERUSER, "root", False, "") self.assertTrue(ret) # Setup a product client to test product API calls. self._pr_client = env.setup_product_client(self.test_workspace_main) self.assertIsNotNone(self._pr_client) # Setup a product client to test product API calls which requires root. self._root_client = env.setup_product_client(self.test_workspace_main, session_token=root_token) self.assertIsNotNone(self._pr_client) # Get the run names which belong to this test. run_names = env.get_run_names(self.test_workspace_main) runs = self._cc_client.getRunData(None) test_runs = [run for run in runs if run.name in run_names] self.assertEqual(len(test_runs), 1, "There should be only one run for this test.") self._runid = test_runs[0].runId # Start a second server with the same configuration database as the # main one. self.test_workspace_secondary = env.get_workspace('producttest_second') self.codechecker_cfg_2 = { 'check_env': self.test_cfg['codechecker_cfg']['check_env'], 'workspace': self.test_workspace_secondary, 'checkers': [], 'viewer_host': 'localhost', 'viewer_port': env.get_free_port(), 'viewer_product': 'producttest_second' } self.codechecker_cfg_2['check_env']['HOME'] = \ self.test_workspace_secondary env.export_test_cfg(self.test_workspace_secondary, {'codechecker_cfg': self.codechecker_cfg_2}) start_server(self.codechecker_cfg_2, EVENT) # Set up API clients for the secondary server. self._auth_client_2 = env.setup_auth_client( self.test_workspace_secondary, session_token='_PROHIBIT') root_token_2 = self._auth_client_2.performLogin( "Username:Password", "root:root") self._pr_client_2 = env.setup_product_client( self.test_workspace_secondary, session_token=root_token_2) self.assertIsNotNone(self._pr_client_2)
def testShutdownTerminateByCmdline(self): """Tests that the command-line command actually kills the server, and that it does not kill anything else.""" # NOTE: Yet again keep the lexicographical flow, no renames! test_cfg = env.import_test_cfg(self._test_workspace) codechecker_1 = test_cfg['codechecker_1'] codechecker_2 = test_cfg['codechecker_2'] EVENT_2.clear() start_server(codechecker_2, EVENT_2, ['--skip-db-cleanup']) # Kill the server, but yet again give a grace period. self.assertEqual(0, self.run_cmd([env.codechecker_cmd(), 'server', '--stop', '--view-port', str(codechecker_2['viewer_port']), '--workspace', self._test_workspace]), "The stop command didn't return exit code 0.") # Check if the remaining server is still there, # we need to make sure that --stop only kills the specified server! instance_1 = [i for i in instance_manager.get_instances(self.home) if i['port'] == codechecker_1['viewer_port'] and i['workspace'] == self._test_workspace] instance_2 = [i for i in instance_manager.get_instances(self.home) if i['port'] == codechecker_2['viewer_port'] and i['workspace'] == self._test_workspace] self.assertNotEqual(instance_1, [], "The stopped server deleted another server's " "record from the instance list!") self.assertEqual(instance_2, [], "The stopped server did not disappear from the" " instance list.") # Kill the first server via cmdline too. self.assertEqual(0, self.run_cmd([env.codechecker_cmd(), 'server', '--stop', '--view-port', str(codechecker_1['viewer_port']), '--workspace', self._test_workspace]), "The stop command didn't return exit code 0.") instance_1 = [i for i in instance_manager.get_instances(self.home) if i['port'] == codechecker_1['viewer_port'] and i['workspace'] == self._test_workspace] instance_2 = [i for i in instance_manager.get_instances(self.home) if i['port'] == codechecker_2['viewer_port'] and i['workspace'] == self._test_workspace] self.assertEqual(instance_1, [], "The stopped server did not disappear from the" " instance list.") self.assertEqual(instance_2, [], "The stopped server made another server's record " "appear in the instance list.")
def setUp(self): self._test_workspace = os.environ.get('TEST_WORKSPACE') test_class = self.__class__.__name__ print('Running ' + test_class + ' tests in ' + self._test_workspace) self._clang_to_test = env.clang_to_test() self._testproject_data = env.setup_test_proj_cfg(self._test_workspace) self.assertIsNotNone(self._testproject_data) # Get the test configuration from the prepared int the test workspace. self.test_cfg = env.import_test_cfg(self._test_workspace) self._product_name = self.test_cfg['codechecker_cfg']['viewer_product'] pr_client = env.setup_product_client(self._test_workspace, product=self._product_name) product_id = pr_client.getCurrentProduct().id # Setup an authentication client for creating sessions. self._auth_client = env.setup_auth_client(self._test_workspace, session_token='_PROHIBIT') # Create an PRODUCT_ADMIN login. admin_token = self._auth_client.performLogin("Username:Password", "admin:admin123") extra_params = '{"productID":' + str(product_id) + '}' ret = self._auth_client.addPermission(Permission.PRODUCT_ADMIN, "admin", False, extra_params) self.assertTrue(ret) self._cc_client = env.setup_viewer_client(self._test_workspace, session_token=admin_token) self.assertIsNotNone(self._cc_client) # Get the run names which belong to this test run_names = env.get_run_names(self._test_workspace) runs = self._cc_client.getRunData(None, None, 0, None) test_runs = [run for run in runs if run.name in run_names] self.assertEqual(len(test_runs), 1, 'There should be only one run for this test.') self._runid = test_runs[0].runId self._run_name = test_runs[0].name self.components = [{ 'name': 'test_component1', 'value': '\n'.join(['+*/divide_zero.cpp', '-*/new_delete.cpp']), 'description': 'Description of my first component' }, { 'name': 'component name with whitespaces', 'value': '\n'.join(['+*/divide_zero.cpp', '-*/new_delete.cpp']), 'description': 'Description of my second component' }, { 'name': 'test_component2', 'value': '\n'.join([ '+*/divide_zero.cpp', '+*/null_dereference.cpp', '-*/call_and_message.cpp', '-*/new_delete.*' ]), 'description': 'Description of my second component' }, { 'name': 'complex1', 'value': '\n'.join(['+*/divide_zero.cpp', '-*/call_and_message.cpp']) }, { 'name': 'complex2', 'value': '\n'.join(['+*/null_dereference.cpp', '-*/new_delete.cpp']) }, { 'name': 'exclude_all', 'value': '-*' }]
def setUp(self): self._test_workspace = os.environ.get('TEST_WORKSPACE') test_class = self.__class__.__name__ print('Running ' + test_class + ' tests in ' + self._test_workspace) self._clang_to_test = env.clang_to_test() self._testproject_data = env.setup_test_proj_cfg(self._test_workspace) self.assertIsNotNone(self._testproject_data) # Get the test configuration from the prepared int the test workspace. self.test_cfg = env.import_test_cfg(self._test_workspace) self._product_name = self.test_cfg['codechecker_cfg']['viewer_product'] pr_client = env.setup_product_client( self._test_workspace, product=self._product_name) product_id = pr_client.getCurrentProduct().id # Setup an authentication client for creating sessions. self._auth_client = env.setup_auth_client(self._test_workspace, session_token='_PROHIBIT') # Create an PRODUCT_ADMIN login. admin_token = self._auth_client.performLogin("Username:Password", "admin:admin123") extra_params = '{"productID":' + str(product_id) + '}' ret = self._auth_client.addPermission(Permission.PRODUCT_ADMIN, "admin", False, extra_params) self.assertTrue(ret) self._cc_client = env.setup_viewer_client(self._test_workspace, session_token=admin_token) self.assertIsNotNone(self._cc_client) # Get the run names which belong to this test run_names = env.get_run_names(self._test_workspace) runs = self._cc_client.getRunData(None) test_runs = [run for run in runs if run.name in run_names] self.assertEqual(len(test_runs), 1, 'There should be only one run for this test.') self._runid = test_runs[0].runId self._run_name = test_runs[0].name self.components = [ { 'name': 'test_component1', 'value': '\n'.join(['+*/divide_zero.cpp', '-*/new_delete.cpp']), 'description': 'Description of my first component' }, { 'name': 'component name with whitespaces', 'value': '\n'.join(['+*/divide_zero.cpp', '-*/new_delete.cpp']), 'description': 'Description of my second component' }, { 'name': 'test_component2', 'value': '\n'.join(['+*/divide_zero.cpp', '+*/null_dereference.cpp', '-*/call_and_message.cpp', '-*/new_delete.*']), 'description': 'Description of my second component' }, { 'name': 'complex1', 'value': '\n'.join(['+*/divide_zero.cpp', '-*/call_and_message.cpp']) }, { 'name': 'complex2', 'value': '\n'.join(['+*/null_dereference.cpp', '-*/new_delete.cpp']) }, { 'name': 'exclude_all', 'value': '-*' } ]
def testShutdownTerminateByCmdline(self): """Tests that the command-line command actually kills the server, and that it does not kill anything else.""" # NOTE: Yet again keep the lexicographical flow, no renames! test_cfg = env.import_test_cfg(self._test_workspace) codechecker_1 = test_cfg['codechecker_1'] codechecker_2 = test_cfg['codechecker_2'] EVENT_2.clear() start_server(codechecker_2, EVENT_2, ['--skip-db-cleanup']) # Kill the server, but yet again give a grace period. self.assertEqual( 0, self.run_cmd([ env.codechecker_cmd(), 'server', '--stop', '--view-port', str(codechecker_2['viewer_port']), '--workspace', self._test_workspace ]), "The stop command didn't return exit code 0.") # Check if the remaining server is still there, # we need to make sure that --stop only kills the specified server! instance_1 = [ i for i in instance_manager.get_instances(self.home) if i['port'] == codechecker_1['viewer_port'] and i['workspace'] == self._test_workspace ] instance_2 = [ i for i in instance_manager.get_instances(self.home) if i['port'] == codechecker_2['viewer_port'] and i['workspace'] == self._test_workspace ] self.assertNotEqual( instance_1, [], "The stopped server deleted another server's " "record from the instance list!") self.assertEqual( instance_2, [], "The stopped server did not disappear from the" " instance list.") # Kill the first server via cmdline too. self.assertEqual( 0, self.run_cmd([ env.codechecker_cmd(), 'server', '--stop', '--view-port', str(codechecker_1['viewer_port']), '--workspace', self._test_workspace ]), "The stop command didn't return exit code 0.") instance_1 = [ i for i in instance_manager.get_instances(self.home) if i['port'] == codechecker_1['viewer_port'] and i['workspace'] == self._test_workspace ] instance_2 = [ i for i in instance_manager.get_instances(self.home) if i['port'] == codechecker_2['viewer_port'] and i['workspace'] == self._test_workspace ] self.assertEqual( instance_1, [], "The stopped server did not disappear from the" " instance list.") self.assertEqual( instance_2, [], "The stopped server made another server's record " "appear in the instance list.")
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_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'])