def setUp(self):
# TEST_WORKSPACE is automatically set by test package __init__.py .
self._test_workspace = os.environ['TEST_WORKSPACE']
# Display test name to log.
test_class = self.__class__.__name__
print(f"Running {test_class} tests in {self._test_workspace}")
# Get the test configuration from the prepared int the test workspace.
test_config = env.import_test_cfg(self._test_workspace)
self.codechecker_cfg = test_config['codechecker_cfg']
# Log in and create credential file (if it is not exists).
self.superuser_name = "root"
self.superuser_passwd = "root"
codechecker.login(test_config['codechecker_cfg'], self._test_workspace,
self.superuser_name, self.superuser_passwd)
self.temp_auth_client = env.setup_auth_client(
self._test_workspace, session_token='_PROHIBIT')
# A non-authenticated session should return an empty user.
user_name = self.temp_auth_client.getLoggedInUser()
self.assertEqual(user_name, "")
self.root_client = self.__get_auth_client(self.superuser_name,
self.superuser_passwd)
def test_garbage_file_collection(self):
event = multiprocessing.Event()
event.clear()
self.codechecker_cfg['viewer_port'] = env.get_free_port()
env.export_test_cfg(self.test_workspace,
{'codechecker_cfg': self.codechecker_cfg})
env.enable_auth(self.test_workspace)
server_access = codechecker.start_server(self.codechecker_cfg, event)
server_access['viewer_port'] \
= self.codechecker_cfg['viewer_port']
server_access['viewer_product'] \
= self.codechecker_cfg['viewer_product']
codechecker.add_test_package_product(server_access,
self.test_workspace)
self._cc_client = env.setup_viewer_client(self.test_workspace)
self.assertIsNotNone(self._cc_client)
self.__create_test_dir()
files_in_report_before = self.__get_files_in_report()
self.__rename_project_dir()
files_in_report_after = self.__get_files_in_report()
event.set()
time.sleep(5)
event.clear()
self.codechecker_cfg['viewer_port'] = env.get_free_port()
env.export_test_cfg(self.test_workspace,
{'codechecker_cfg': self.codechecker_cfg})
codechecker.start_server(self.codechecker_cfg, event)
codechecker.login(self.codechecker_cfg, self.test_workspace, 'cc',
'test')
self._cc_client = env.setup_viewer_client(self.test_workspace)
self.assertIsNotNone(self._cc_client)
self.assertEqual(len(files_in_report_before & files_in_report_after),
0)
for file_id in files_in_report_before:
f = self._cc_client.getSourceFileData(file_id, False, None)
self.assertIsNone(f.fileId)
event.set()
time.sleep(5)
def setUp(self):
# TEST_WORKSPACE is automatically set by test package __init__.py .
self._test_workspace = os.environ['TEST_WORKSPACE']
# Display test name to log.
test_class = self.__class__.__name__
print(f"Running {test_class} tests in {self._test_workspace}")
# Get the test configuration from the prepared int the test workspace.
test_config = env.import_test_cfg(self._test_workspace)
# Log in and create credential file (if it is not exists).
superuser_name = "root"
superuser_passwd = "root"
codechecker.login(test_config['codechecker_cfg'],
self._test_workspace, superuser_name,
superuser_passwd)
temp_auth_client = env.setup_auth_client(self._test_workspace,
session_token='_PROHIBIT')
# A non-authenticated session should return an empty user.
user_name = temp_auth_client.getLoggedInUser()
self.assertEqual(user_name, "")
# Create a SUPERUSER login.
self._session_token = temp_auth_client.performLogin(
"Username:Password", f"{superuser_name}:{superuser_passwd}")
self.assertIsNotNone(self._session_token,
"Valid credentials didn't give us a token!")
# Connect as root to the server.
self._root_auth_client = env.setup_auth_client(
self._test_workspace, session_token=self._session_token)
user_name = self._root_auth_client.getLoggedInUser()
self.assertEqual(user_name, superuser_name)
# Query data of current product
self._product_name = test_config['codechecker_cfg']['viewer_product']
self._product_client = env.setup_product_client(
self._test_workspace, product=self._product_name)
self.assertIsNotNone(self._product_client)
self._current_product = self._product_client.getCurrentProduct()
self.assertIsNotNone(self._current_product)
self._product_id = self._current_product.id
self.assertIsNotNone(self._product_id)
self._extra_params = json.dumps({'productID': self._product_id})
def test_garbage_file_collection(self):
event = multiprocessing.Event()
event.clear()
self.codechecker_cfg['viewer_port'] = env.get_free_port()
env.export_test_cfg(self.test_workspace,
{'codechecker_cfg': self.codechecker_cfg})
env.enable_auth(self.test_workspace)
server_access = codechecker.start_server(self.codechecker_cfg, event)
server_access['viewer_port'] \
= self.codechecker_cfg['viewer_port']
server_access['viewer_product'] \
= self.codechecker_cfg['viewer_product']
codechecker.add_test_package_product(server_access,
self.test_workspace)
self._cc_client = env.setup_viewer_client(self.test_workspace)
self.assertIsNotNone(self._cc_client)
self.__create_test_dir()
files_in_report_before = self.__get_files_in_report()
# Checker severity levels.
self.__check_serverity_of_reports()
self.__rename_project_dir()
# Delete previous analysis report directory.
rmtree(self.codechecker_cfg['reportdir'])
files_in_report_after = self.__get_files_in_report()
event.set()
time.sleep(5)
event.clear()
# Change severity level of core.DivideZero to LOW.
with io.open(self.workspace_severity_cfg, 'r+') as severity_cgf_file:
severity_map = json.load(severity_cgf_file)
severity_map['core.DivideZero'] = 'LOW'
severity_cgf_file.seek(0)
severity_cgf_file.truncate()
severity_cgf_file.write(unicode(json.dumps(severity_map)))
self.codechecker_cfg['viewer_port'] = env.get_free_port()
env.export_test_cfg(self.test_workspace,
{'codechecker_cfg': self.codechecker_cfg})
codechecker.start_server(self.codechecker_cfg, event)
codechecker.login(self.codechecker_cfg, self.test_workspace, 'cc',
'test')
self._cc_client = env.setup_viewer_client(self.test_workspace)
self.assertIsNotNone(self._cc_client)
self.assertEqual(len(files_in_report_before & files_in_report_after),
0)
for file_id in files_in_report_before:
f = self._cc_client.getSourceFileData(file_id, False, None)
self.assertIsNone(f.fileId)
# Checker severity levels.
self.__check_serverity_of_reports()
event.set()
time.sleep(5)
def test_read_product_from_another_server(self):
"""
Test if adding and removing a product is visible from the other server.
"""
# Check if the main server's product is visible on the second server.
self.assertEqual(
self._pr_client_2.getProducts('producttest',
None)[0].endpoint, 'producttest',
"Main server's product was not loaded by the secondary server.")
def create_test_product(product_name, product_endpoint):
# Create a new product on the secondary server.
name = base64.b64encode(product_name)
return ProductConfiguration(endpoint=product_endpoint,
displayedName_b64=name,
description_b64=name,
connection=DatabaseConnection(
engine='sqlite',
host='',
port=0,
username_b64='',
password_b64='',
database=os.path.join(
self.test_workspace_secondary,
'data.sqlite')))
product_cfg = create_test_product('producttest_second',
'producttest_second')
self.assertTrue(self._pr_client_2.addProduct(product_cfg),
"Cannot create product on secondary server.")
product_cfg = create_test_product('producttest_second 2',
'producttest_second_2')
self.assertTrue(self._pr_client_2.addProduct(product_cfg),
"Cannot create product on secondary server.")
# Product name full string match.
products = self._pr_client_2.getProducts('producttest_second', None)
self.assertEqual(len(products), 1)
# Product endpoint full string match.
products = self._pr_client_2.getProducts(None, 'producttest_second')
self.assertEqual(len(products), 1)
# Product name substring match.
products = self._pr_client_2.getProducts('producttest_second*', None)
self.assertEqual(len(products), 2)
products = self._pr_client_2.getProducts(None, 'producttest_second*')
self.assertEqual(len(products), 2)
# Use the same CodeChecker config that was used on the main server,
# but store into the secondary one.
store_cfg = deepcopy(self.test_cfg['codechecker_cfg'])
store_cfg.update({
'viewer_port':
self.codechecker_cfg_2['viewer_port'],
'viewer_product':
self.codechecker_cfg_2['viewer_product']
})
codechecker.login(store_cfg, self.test_workspace_secondary, 'root',
'root')
store_cfg['reportdir'] = os.path.join(self.test_workspace_main,
'reports')
store_res = codechecker.store(store_cfg, 'test_proj-secondary')
self.assertEqual(store_res, 0, "Storing the test project failed.")
cc_client_2 = env.setup_viewer_client(self.test_workspace_secondary)
self.assertEqual(len(cc_client_2.getRunData(None)), 1,
"There should be a run present in the new server.")
self.assertEqual(
len(self._cc_client.getRunData(None)), 1,
"There should be a run present in the database when "
"connected through the main server.")
# Remove the product through the main server.
p_id = self._root_client.getProducts('producttest_second', None)[0].id
p_id2 = self._pr_client_2.getProducts('producttest_second', None)[0].id
self.assertIsNotNone(p_id)
self.assertEqual(
p_id, p_id2, "The products have different ID across the two "
"servers. WHAT? Database isn't shared?!")
self.assertTrue(self._root_client.removeProduct(p_id),
"Main server reported error while removing product.")
self.assertEqual(len(self._pr_client.getProducts('_second', None)), 0,
"Secondary server still sees the removed product.")
# Try to store into the product just removed through the secondary
# server, which still sees the product internally.
store_res = codechecker.store(store_cfg, 'test_proj-secondary')
self.assertNotEqual(
store_res, 0, "Storing into the server with "
"the product missing should've resulted in "
"an error.")
def test_garbage_file_collection(self):
event = multiprocessing.Event()
event.clear()
self.codechecker_cfg['viewer_port'] = env.get_free_port()
env.export_test_cfg(self.test_workspace,
{'codechecker_cfg': self.codechecker_cfg})
env.enable_auth(self.test_workspace)
server_access = codechecker.start_server(self.codechecker_cfg, event)
server_access['viewer_port'] \
= self.codechecker_cfg['viewer_port']
server_access['viewer_product'] \
= self.codechecker_cfg['viewer_product']
codechecker.add_test_package_product(server_access,
self.test_workspace)
self._cc_client = env.setup_viewer_client(self.test_workspace)
self.assertIsNotNone(self._cc_client)
run_name1 = 'db_cleanup_test'
run_name2 = f'{run_name1}2'
self.__create_test_dir()
# Store the results.
codechecker.check_and_store(self.codechecker_cfg, run_name1,
self.test_dir)
# Store the results to a different run too to see if we remove only one
# run, comments and review statuses not cleared.
codechecker.check_and_store(self.codechecker_cfg, run_name2,
self.test_dir)
run_id1 = self.__get_run_id([run_name1])
report = self._cc_client.getRunResults(None, 1, 0, [], None, None,
False)[0]
report_hash = report.bugHash
report_id = report.reportId
# Add a new comment.
comment = CommentData(author='anybody', message='Msg')
success = self._cc_client.addComment(report_id, comment)
self.assertTrue(success)
# Change review status.
success = self._cc_client.changeReviewStatus(report_id,
ReviewStatus.CONFIRMED,
'Real bug')
self.assertTrue(success)
# Remove the first storage.
self._cc_client.removeRun(run_id1, None)
# Comments and review statuses are not cleared, because the second
# run results still reference them.
run_id2 = self.__get_run_id([run_name2])
r_filter = ReportFilter(reviewStatus=[ReviewStatus.CONFIRMED])
run_results = self._cc_client.getRunResults([run_id2], 1, 0, None,
r_filter, None, False)
self.assertTrue(run_results)
comments = self._cc_client.getComments(run_results[0].reportId)
self.assertTrue(comments)
# Remove the second run too, so it will cleanup the unused commments
# and review statuses.
self._cc_client.removeRun(run_id2, None)
# Store results again and check that previous comments and review
# statuses are gone.
files_in_report_before = self.__get_files_in_report(run_name1)
r_filter = ReportFilter(reportHash=[report_hash])
report = self._cc_client.getRunResults(None, 1, 0, None, r_filter,
None, False)[0]
report_id = report.reportId
comments = self._cc_client.getComments(report_id)
self.assertFalse(comments)
r_filter = ReportFilter(reviewStatus=[ReviewStatus.CONFIRMED])
run_results = self._cc_client.getRunResults(None, 1, 0, None, r_filter,
None, False)
self.assertFalse(run_results)
# Checker severity levels.
self.__check_serverity_of_reports(run_name1)
self.__rename_project_dir()
# Delete previous analysis report directory.
rmtree(self.codechecker_cfg['reportdir'])
files_in_report_after = self.__get_files_in_report(run_name1)
event.set()
event.clear()
# Change severity level of core.DivideZero to LOW.
with open(self.workspace_severity_cfg,
'r+',
encoding='utf-8',
errors='ignore') as severity_cgf_file:
severity_map = json.load(severity_cgf_file)
severity_map['core.DivideZero'] = 'LOW'
severity_cgf_file.seek(0)
severity_cgf_file.truncate()
severity_cgf_file.write(str(json.dumps(severity_map)))
self.codechecker_cfg['viewer_port'] = env.get_free_port()
env.export_test_cfg(self.test_workspace,
{'codechecker_cfg': self.codechecker_cfg})
codechecker.start_server(self.codechecker_cfg, event)
codechecker.login(self.codechecker_cfg, self.test_workspace, 'cc',
'test')
self._cc_client = env.setup_viewer_client(self.test_workspace)
self.assertIsNotNone(self._cc_client)
self.assertEqual(len(files_in_report_before & files_in_report_after),
0)
for file_id in files_in_report_before:
f = self._cc_client.getSourceFileData(file_id, False, None)
self.assertIsNone(f.fileId)
# Checker severity levels.
self.__check_serverity_of_reports(run_name1)
event.set()
def test_garbage_file_collection(self):
event = multiprocessing.Event()
event.clear()
self.codechecker_cfg['viewer_port'] = env.get_free_port()
env.export_test_cfg(self.test_workspace,
{'codechecker_cfg': self.codechecker_cfg})
env.enable_auth(self.test_workspace)
server_access = codechecker.start_server(self.codechecker_cfg, event)
server_access['viewer_port'] \
= self.codechecker_cfg['viewer_port']
server_access['viewer_product'] \
= self.codechecker_cfg['viewer_product']
codechecker.add_test_package_product(server_access,
self.test_workspace)
self._cc_client = env.setup_viewer_client(self.test_workspace)
self.assertIsNotNone(self._cc_client)
self.__create_test_dir()
files_in_report_before = self.__get_files_in_report()
# Checker severity levels.
self.__check_serverity_of_reports()
self.__rename_project_dir()
# Delete previous analysis report directory.
rmtree(self.codechecker_cfg['reportdir'])
files_in_report_after = self.__get_files_in_report()
event.set()
event.clear()
# Change severity level of core.DivideZero to LOW.
with io.open(self.workspace_severity_cfg, 'r+') as severity_cgf_file:
severity_map = json.load(severity_cgf_file)
severity_map['core.DivideZero'] = 'LOW'
severity_cgf_file.seek(0)
severity_cgf_file.truncate()
severity_cgf_file.write(unicode(json.dumps(severity_map)))
self.codechecker_cfg['viewer_port'] = env.get_free_port()
env.export_test_cfg(self.test_workspace,
{'codechecker_cfg': self.codechecker_cfg})
codechecker.start_server(self.codechecker_cfg,
event)
codechecker.login(self.codechecker_cfg,
self.test_workspace,
'cc',
'test')
self._cc_client = env.setup_viewer_client(self.test_workspace)
self.assertIsNotNone(self._cc_client)
self.assertEqual(len(files_in_report_before & files_in_report_after),
0)
for file_id in files_in_report_before:
f = self._cc_client.getSourceFileData(file_id, False, None)
self.assertIsNone(f.fileId)
# Checker severity levels.
self.__check_serverity_of_reports()
event.set()
