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 test_regex_groups(self):
auth_client = env.setup_auth_client(self._test_workspace,
session_token='_PROHIBIT')
# First login as root.
self.sessionToken = auth_client.performLogin("Username:Password",
"root:root")
self.assertIsNotNone(self.sessionToken, "root was unable to login!")
# Then give SUPERUSER privs to admins_custom_group.
authd_auth_client = \
env.setup_auth_client(self._test_workspace,
session_token=self.sessionToken)
ret = authd_auth_client.addPermission(Permission.SUPERUSER,
"admins_custom_group", True,
None)
self.assertTrue(ret)
result = auth_client.destroySession()
self.assertTrue(result, "Server did not allow us to destroy session.")
# Login as a user who is in admins_custom_group.
sessionToken = auth_client.performLogin("Username:Password",
"regex_admin:blah")
self.assertIsNotNone(sessionToken,
"Valid credentials didn't give us a token!")
# Do something privileged.
client = env.setup_viewer_client(self._test_workspace,
session_token=sessionToken)
self.assertIsNotNone(client.allowsStoringAnalysisStatistics(),
"Privileged call failed.")
result = auth_client.destroySession()
self.assertTrue(result, "Server did not allow us to destroy session.")
# Finally try to do the same with an unprivileged user.
sessionToken = auth_client.performLogin("Username:Password",
"john:doe")
self.assertIsNotNone(sessionToken,
"Valid credentials didn't give us a token!")
client = env.setup_viewer_client(self._test_workspace,
session_token=sessionToken)
self.assertFalse(
client.allowsStoringAnalysisStatistics(),
"Privileged call from unprivileged user"
" did not fail!")
result = auth_client.destroySession()
self.assertTrue(result, "Server did not allow us to destroy session.")
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)
sort_mode = RunSortMode(RunSortType.DATE, Order.ASC)
runs = self._cc_client.getRunData(None, None, 0, sort_mode)
test_runs = [run for run in runs if run.name in run_names]
self._runid = test_runs[0].runId
self._project_info = env.setup_test_proj_cfg(test_workspace)
def setUp(self):
self.test_workspace = os.environ['TEST_WORKSPACE']
test_class = self.__class__.__name__
print('Running ' + test_class + ' tests in ' + self.test_workspace)
self._testproject_data = env.setup_test_proj_cfg(self.test_workspace)
self.assertIsNotNone(self._testproject_data)
self._cc_client = env.setup_viewer_client(self.test_workspace)
self.assertIsNotNone(self._cc_client)
# Get the run names which belong to this test.
run_names = env.get_run_names(self.test_workspace)
# get the current run data
run_filter = RunFilter(names=run_names, exactMatch=True)
runs = self._cc_client.getRunData(run_filter, 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, '
'with the given name configured at the test init.')
self._runid = test_runs[0].runId
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)
self._cc_client = env.setup_viewer_client(self._test_workspace)
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
def setUp(self):
test_workspace = os.environ['TEST_WORKSPACE']
test_class = self.__class__.__name__
print('Running ' + test_class + ' tests in ' + test_workspace)
self._codechecker_cfg = env.import_codechecker_cfg(test_workspace)
self._test_dir = os.path.join(test_workspace, 'test_files')
# 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]
self._runid = test_runs[0].runId
def setUp(self):
# Get the test workspace used to cppcheck 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)
self._codechecker_cfg = self._test_cfg["codechecker_cfg"]
self._test_directory = os.path.dirname(
os.path.abspath(inspect.getfile(inspect.currentframe())))
self._temp_workspace = os.path.join(self._codechecker_cfg["workspace"],
"test_proj")
self._divide_zero_workspace = os.path.join(self._temp_workspace,
"divide_zero")
self._double_suppress_workspace = os.path.join(self._temp_workspace,
"double_suppress")
self.product_name = self._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)
self._pr_client = env.setup_product_client(self._test_workspace,
product=self.product_name)
self.assertIsNotNone(self._pr_client)
def setUp(self):
test_workspace = os.environ['TEST_WORKSPACE']
test_class = self.__class__.__name__
print('Running ' + test_class + ' tests in ' + test_workspace)
self._codechecker_cfg = env.import_codechecker_cfg(test_workspace)
self._test_dir = os.path.join(test_workspace, 'test_files')
# 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]
self._runid = test_runs[0].runId
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)
# Get the clang version which is tested.
self._clang_to_test = env.clang_to_test()
# Get the test 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 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]
self.assertEqual(len(test_runs), 1,
"There should be only one run for this test.")
self._runid = test_runs[0].runId
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)
# Get the test configuration from the prepared int the test workspace.
self._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.
self._run_names = env.get_run_names(test_workspace)
local_test_project = \
self._test_cfg['test_project']['project_path_local']
self._local_reports = os.path.join(local_test_project, 'reports')
self._url = env.parts_to_url(self._test_cfg['codechecker_cfg'])
self._env = self._test_cfg['codechecker_cfg']['check_env']
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)
# Setup a server client to test server API calls.
self._report = env.setup_server_client(test_workspace)
# 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()
test_runs = [run for run in runs if run.name in run_names]
def setUp(self):
test_workspace = os.environ['TEST_WORKSPACE']
test_class = self.__class__.__name__
print('Running ' + test_class + ' tests in ' + test_workspace)
test_cfg = env.import_test_cfg(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()
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 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()
# Get the run names which belong to this test.
run_names = env.get_run_names(test_workspace)
runs = self._cc_client.getRunData(None, None, 0, None)
self.test_runs = [run for run in runs if run.name in run_names]
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)
self._cc_client = env.setup_viewer_client(self._test_workspace)
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
def setUp(self):
"""
Not much setup is needed.
Runs and results are automatically generated.
"""
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._report = env.setup_viewer_client(test_workspace)
self.assertIsNotNone(self._report)
# Store runs to check.
self._codechecker_cfg = env.import_codechecker_cfg(test_workspace)
source_dir = os.path.join(os.path.dirname(__file__), 'test_files')
self._test_dir = os.path.join(test_workspace, 'test_files')
shutil.copytree(source_dir, self._test_dir)
_replace_path(os.path.join(self._test_dir, 'run.plist'),
self._test_dir)
self._codechecker_cfg['reportdir'] = self._test_dir
codechecker.store(self._codechecker_cfg,
'test_hash_clash_' + uuid4().hex)
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()
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
def setUp(self):
# Get the test workspace.
self.test_workspace = os.environ['TEST_WORKSPACE']
test_class = self.__class__.__name__
print('Running ' + test_class + ' tests in ' + self.test_workspace)
self._codechecker_cfg = env.import_codechecker_cfg(self.test_workspace)
self._reports_dir = self._codechecker_cfg['reportdir']
# Get the CodeChecker cmd if needed for the tests.
self._codechecker_cmd = env.codechecker_cmd()
self._test_dir = os.path.join(self.test_workspace, 'test_files')
self._product_name = self._codechecker_cfg['viewer_product']
self._analyzer_stats_dir = os.path.join(self.test_workspace,
'analysis_statistics')
try:
os.makedirs(self._test_dir)
except os.error:
# Directory already exists.
pass
# Setup a viewer client to test viewer API calls.
self._cc_client = env.setup_viewer_client(self.test_workspace)
self.assertIsNotNone(self._cc_client)
# Change working dir to testfile dir so CodeChecker can be run easily.
self.__old_pwd = os.getcwd()
os.chdir(self._test_dir)
self._source_file = "main.cpp"
# Init project dir.
makefile_content = "all:\n\t$(CXX) -c main.cpp -o /dev/null\n"
project_info_content = {
"name": "hello",
"clean_cmd": "",
"build_cmd": "make"
}
makefile = os.path.join(self._test_dir, 'Makefile')
with open(makefile, 'w', encoding="utf-8", errors="ignore") as make_f:
make_f.write(makefile_content)
project_info = os.path.join(self._test_dir, 'project_info.json')
with open(project_info, 'w',
encoding="utf-8", errors="ignore") as info_f:
json.dump(project_info_content, info_f)
self.sources = ["""
int main()
{
return 1 / 0; // Division by zero
}""", """
int main()
{
return 0;
xxx // Will cause a compilation error
}"""]
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 setUp(self):
# Get the test workspace.
self.test_workspace = os.environ['TEST_WORKSPACE']
test_class = self.__class__.__name__
print('Running ' + test_class + ' tests in ' + self.test_workspace)
self._codechecker_cfg = env.import_codechecker_cfg(self.test_workspace)
self._reports_dir = self._codechecker_cfg['reportdir']
# Get the CodeChecker cmd if needed for the tests.
self._codechecker_cmd = env.codechecker_cmd()
self._test_dir = os.path.join(self.test_workspace, 'test_files')
self._product_name = self._codechecker_cfg['viewer_product']
self._analyzer_stats_dir = os.path.join(self.test_workspace,
'analysis_statistics')
try:
os.makedirs(self._test_dir)
except os.error:
# Directory already exists.
pass
# Setup a viewer client to test viewer API calls.
self._cc_client = env.setup_viewer_client(self.test_workspace)
self.assertIsNotNone(self._cc_client)
# Change working dir to testfile dir so CodeChecker can be run easily.
self.__old_pwd = os.getcwd()
os.chdir(self._test_dir)
self._source_file = "main.cpp"
# Init project dir.
makefile_content = "all:\n\t$(CXX) -c main.cpp -o /dev/null\n"
project_info_content = {
"name": "hello",
"clean_cmd": "",
"build_cmd": "make"
}
makefile = os.path.join(self._test_dir, 'Makefile')
with open(makefile, 'w') as make_f:
make_f.write(makefile_content)
project_info = os.path.join(self._test_dir, 'project_info.json')
with open(project_info, 'w') as info_f:
json.dump(project_info_content, info_f)
self.sources = ["""
int main()
{
return 1 / 0; // Division by zero
}""", """
int main()
{
return 0;
xxx // Will cause a compilation error
}"""]
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)
self._codechecker_cfg = env.import_codechecker_cfg(self.test_workspace)
self._test_dir = os.path.join(self.test_workspace, 'test_files')
try:
os.makedirs(self._test_dir)
except os.error:
# Directory already exists.
pass
# Setup a viewer client to test viewer API calls.
self._cc_client = env.setup_viewer_client(self.test_workspace)
self.assertIsNotNone(self._cc_client)
# Change working dir to testfile dir so CodeChecker can be run easily.
self.__old_pwd = os.getcwd()
os.chdir(self._test_dir)
self._source_file = "main.cpp"
# Init project dir.
makefile = "all:\n\t$(CXX) -c main.cpp -o /dev/null\n"
project_info = {
"name": "test_run_tag",
"clean_cmd": "",
"build_cmd": "make"
}
with open(os.path.join(self._test_dir, 'Makefile'), 'w') as f:
f.write(makefile)
with open(os.path.join(self._test_dir, 'project_info.json'), 'w') as f:
json.dump(project_info, f)
self.sources = [
"""
int main()
{
sizeof(42);
sizeof(43);
}""", """
int main()
{
sizeof(43);
sizeof(44);
sizeof(45);
}""", """
int main()
{
sizeof(45);
}"""
]
self.tags = ['v1.0', 'v1.1', 'v1.2']
def test_privileged_access(self):
"""
Tests that initially, a non-authenticating server is accessible,
but an authenticating one is not.
"""
auth_client = env.setup_auth_client(self._test_workspace)
handshake = auth_client.getAuthParameters()
self.assertTrue(
handshake.requiresAuthentication, "Privileged server " +
"did not report that it requires authentication.")
self.assertFalse(handshake.sessionStillActive,
"Empty session was " + "reported to be still active.")
sessionToken = auth_client.performLogin("Username:Password",
"invalid:invalid")
self.assertIsNone(sessionToken, "Invalid credentials gave us a token!")
self.sessionToken = auth_client.performLogin("Username:Password",
"cc:test")
self.assertIsNotNone(self.sessionToken,
"Valid credentials didn't give us a token!")
handshake = auth_client.getAuthParameters()
self.assertTrue(
handshake.requiresAuthentication, "Privileged server " +
"did not report that it requires authentication.")
self.assertFalse(handshake.sessionStillActive,
"Valid session was " + "reported not to be active.")
client = env.setup_viewer_client(self._test_workspace,
session_token=self.sessionToken)
self.assertIsNotNone(client.getAPIVersion(),
"Privileged server didn't respond properly.")
auth_client = env.setup_auth_client(self._test_workspace,
session_token=self.sessionToken)
result = auth_client.destroySession()
self.assertTrue(result, "Server did not allow us to destroy session.")
try:
client.getAPIVersion()
success = False
except TProtocolException as tpe:
# The server reports a HTTP 401 error which
# is not a valid Thrift response.
# But if it does so, it passes the test!
success = True
self.assertTrue(success,
"Privileged client allowed access after logout.")
handshake = auth_client.getAuthParameters()
self.assertFalse(
handshake.sessionStillActive,
"Destroyed session was " + "reported to be still active.")
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)
self._codechecker_cfg = env.import_codechecker_cfg(self.test_workspace)
self._test_dir = os.path.join(self.test_workspace, 'test_files')
try:
os.makedirs(self._test_dir)
except os.error:
# Directory already exists.
pass
# Setup a viewer client to test viewer API calls.
self._cc_client = env.setup_viewer_client(self.test_workspace)
self.assertIsNotNone(self._cc_client)
# Change working dir to testfile dir so CodeChecker can be run easily.
self.__old_pwd = os.getcwd()
os.chdir(self._test_dir)
self._source_file = "main.cpp"
# Init project dir.
makefile = "all:\n\t$(CXX) -c main.cpp -o /dev/null\n"
project_info = {
"name": "test_run_tag",
"clean_cmd": "",
"build_cmd": "make"
}
with open(os.path.join(self._test_dir, 'Makefile'), 'w') as f:
f.write(makefile)
with open(os.path.join(self._test_dir, 'project_info.json'), 'w') as f:
json.dump(project_info, f)
self.sources = ["""
int main()
{
sizeof(42);
sizeof(43);
}""", """
int main()
{
sizeof(43);
sizeof(44);
sizeof(45);
}""", """
int main()
{
sizeof(45);
}"""]
self.tags = ['v1.0', 'v1.1', 'v1.2']
def test_group_auth(self):
"""
Test for case insensitive group comparison at authorization.
"""
auth_client = env.setup_auth_client(self._test_workspace,
session_token='_PROHIBIT')
# A non-authenticated session should return an empty user.
user = auth_client.getLoggedInUser()
self.assertEqual(user, "")
# Create a SUPERUSER login.
self.sessionToken = auth_client.performLogin("Username:Password",
"root:root")
self.assertIsNotNone(self.sessionToken,
"Valid credentials didn't give us a token!")
authd_auth_client = \
env.setup_auth_client(self._test_workspace,
session_token=self.sessionToken)
user = authd_auth_client.getLoggedInUser()
self.assertEqual(user, "root")
product_name = self._test_cfg['codechecker_cfg']['viewer_product']
pr_client = env.setup_product_client(self._test_workspace,
product=product_name)
product_id = pr_client.getCurrentProduct().id
extra_params = {'productID': product_id}
ret = authd_auth_client.addPermission(Permission.PRODUCT_ADMIN,
"ADMIN_group", True,
json.dumps(extra_params))
self.assertTrue(ret)
result = auth_client.destroySession()
self.assertTrue(result, "Server did not allow us to destroy session.")
# Perform login with a user who is in ADMIN_GROUP and check that
# he has permission to perform operations.
self.sessionToken = \
auth_client.performLogin("Username:Password",
"admin_group_user:admin123")
self.assertIsNotNone(self.sessionToken,
"Valid credentials didn't give us a token!")
client = env.setup_viewer_client(self._test_workspace,
session_token=self.sessionToken)
self.assertIsNotNone(client.allowsStoringAnalysisStatistics(),
"Privileged server didn't respond properly.")
result = auth_client.destroySession()
self.assertTrue(result, "Server did not allow us to destroy session.")
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._testproject_data = env.setup_test_proj_cfg(self._test_workspace)
self.assertIsNotNone(self._testproject_data)
self._cc_client = env.setup_viewer_client(self._test_workspace)
self.assertIsNotNone(self._cc_client)
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._component_name = 'dummy_component'
self._component_value = '\n'.join(
['+*/divide_zero.cpp', '-*/new_delete.cpp'])
self._component_description = "Test component"
def setUp(self):
test_workspace = os.environ['TEST_WORKSPACE']
test_class = self.__class__.__name__
print('Running ' + test_class + ' tests in ' + test_workspace)
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)
self._run_names = env.get_run_names(test_workspace)
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)
auth_client = env.setup_auth_client(self._test_workspace,
session_token='_PROHIBIT')
sessionToken_cc = auth_client.performLogin("Username:Password",
"cc:test")
sessionToken_john = auth_client.performLogin("Username:Password",
"john:doe")
self._cc_client =\
env.setup_viewer_client(
self._test_workspace,
session_token=sessionToken_cc)
self._cc_client_john =\
env.setup_viewer_client(
self._test_workspace,
session_token=sessionToken_john)
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)
self._test_runs = [run for run in runs if run.name in run_names]
self.assertEqual(len(self._test_runs), 2,
'There should be two runs for this test.')
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)
auth_client = env.setup_auth_client(self._test_workspace,
session_token='_PROHIBIT')
sessionToken_cc = auth_client.performLogin("Username:Password",
"cc:test")
sessionToken_john = auth_client.performLogin("Username:Password",
"john:doe")
self._cc_client =\
env.setup_viewer_client(
self._test_workspace,
session_token=sessionToken_cc)
self._cc_client_john =\
env.setup_viewer_client(
self._test_workspace,
session_token=sessionToken_john)
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)
self._test_runs = [run for run in runs if run.name in run_names]
self.assertEqual(len(self._test_runs), 2,
'There should be two runs for this test.')
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)
# Get the clang version which is tested.
self._clang_to_test = env.clang_to_test()
# Get the test project configuration from the prepared test workspace.
self._testproject_data = env.setup_test_proj_cfg(self.test_workspace)
self.assertIsNotNone(self._testproject_data)
# Setup a viewer client to test viewer API calls.
self._cc_client = env.setup_viewer_client(self.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.
# Name order matters from __init__ !
run_names = env.get_run_names(self.test_workspace)
sort_mode = RunSortMode(RunSortType.DATE, Order.ASC)
runs = self._cc_client.getRunData(None, None, 0, sort_mode)
self._test_runs = [run for run in runs if run.name in run_names]
# 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 = self._test_runs[0].runId
self._new_runid = self._test_runs[1].runId
self._update_runid = self._test_runs[2].runId
self._url = env.parts_to_url(self.test_cfg['codechecker_cfg'])
self._env = self.test_cfg['codechecker_cfg']['check_env']
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 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, 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
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._cc_client = env.setup_viewer_client(self._test_workspace)
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), 2,
'There should be two runs for this test.')
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._cc_client = env.setup_viewer_client(self._test_workspace)
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), 2,
'There should be two runs for this test.')
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 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 setUp(self):
"""
Not much setup is needed.
Runs and results are automatically generated.
"""
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._report = env.setup_viewer_client(test_workspace)
self.assertIsNotNone(self._report)
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)
self._cc_port = env.import_test_cfg(
test_workspace)['codechecker_cfg']['viewer_port']
# 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()
def setUp(self):
"""
Setup Configuration for tests.
"""
# 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)
# Setup a viewer client to test viewer API calls.
self._cc_client = env.setup_viewer_client(self._test_workspace)
self.assertIsNotNone(self._cc_client)
self.auth_client = env.setup_auth_client(self._test_workspace,
session_token='_PROHIBIT')
self.config_client = env.setup_config_client(self._test_workspace,
session_token='_PROHIBIT')
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 project configuration from the prepared test workspace.
self._testproject_data = env.setup_test_proj_cfg(self.test_workspace)
self.assertIsNotNone(self._testproject_data)
# Setup a viewer client to test viewer API calls.
self._cc_client = env.setup_viewer_client(self.test_workspace)
self.assertIsNotNone(self._cc_client)
# Get the CodeChecker cmd if needed for the tests.
self._codechecker_cmd = env.codechecker_cmd()
self._codechecker_cfg = env.import_codechecker_cfg(self.test_workspace)
self.env = env.codechecker_env()
def setUp(self):
self._test_workspace = os.environ['TEST_WORKSPACE']
self._testproject_data = env.setup_test_proj_cfg(self._test_workspace)
self.assertIsNotNone(self._testproject_data)
self._test_project_path = self._testproject_data['project_path']
self._cc_client = env.setup_viewer_client(self._test_workspace)
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
def setUp(self):
self._test_workspace = os.environ['TEST_WORKSPACE']
self._testproject_data = env.setup_test_proj_cfg(self._test_workspace)
self.assertIsNotNone(self._testproject_data)
self._test_project_path = self._testproject_data['project_path']
self._cc_client = env.setup_viewer_client(self._test_workspace)
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
def setUp(self):
test_workspace = os.environ.get('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 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 test_privileged_access(self):
"""
Tests that initially, a non-authenticating server is accessible,
but an authenticating one is not.
"""
auth_client = env.setup_auth_client(self._test_workspace,
session_token='_PROHIBIT')
handshake = auth_client.getAuthParameters()
self.assertTrue(handshake.requiresAuthentication,
"Privileged server " +
"did not report that it requires authentication.")
self.assertFalse(handshake.sessionStillActive, "Empty session was " +
"reported to be still active.")
with self.assertRaises(RequestFailed):
auth_client.performLogin("Username:Password", "invalid:invalid")
print("Invalid credentials gave us a token!")
# A non-authenticated session should return an empty user.
user = auth_client.getLoggedInUser()
self.assertEqual(user, "")
# We still need to create a product on the new server, because
# in PostgreSQL mode, the same database is used for configuration
# by the newly started instance of this test suite too.
codechecker.add_test_package_product(
self._test_cfg['codechecker_cfg'],
self._test_workspace,
# Use the test's home directory to find the session token file.
self._test_cfg['codechecker_cfg']['check_env'])
self.sessionToken = auth_client.performLogin("Username:Password",
"cc:test")
self.assertIsNotNone(self.sessionToken,
"Valid credentials didn't give us a token!")
handshake = auth_client.getAuthParameters()
self.assertTrue(handshake.requiresAuthentication,
"Privileged server " +
"did not report that it requires authentication.")
self.assertFalse(handshake.sessionStillActive,
"Valid session was " + "reported not to be active.")
client = env.setup_viewer_client(self._test_workspace,
session_token=self.sessionToken)
self.assertIsNotNone(client.getPackageVersion(),
"Privileged server didn't respond properly.")
authd_auth_client = \
env.setup_auth_client(self._test_workspace,
session_token=self.sessionToken)
user = authd_auth_client.getLoggedInUser()
self.assertEqual(user, "cc")
# No personal token in the database.
personal_tokens = authd_auth_client.getTokens()
self.assertEqual(len(personal_tokens), 0)
# Create a new personal token.
description = "description"
personal_token = authd_auth_client.newToken(description)
token = personal_token.token
self.assertEqual(personal_token.description, description)
# Check whether the new token has been added.
personal_tokens = authd_auth_client.getTokens()
self.assertEqual(len(personal_tokens), 1)
self.assertEqual(personal_tokens[0].token, token)
self.assertEqual(personal_tokens[0].description, description)
auth_client = env.setup_auth_client(self._test_workspace,
session_token=self.sessionToken)
result = auth_client.destroySession()
self.assertTrue(result, "Server did not allow us to destroy session.")
self.sessionToken = auth_client.performLogin("Username:Password",
"colon:my:password")
self.assertIsNotNone(self.sessionToken,
"Valid credentials didn't give us a token!")
result = auth_client.destroySession()
self.assertTrue(result, "Server did not allow us to destroy session.")
# Kill the session token that was created by login() too.
codechecker.logout(self._test_cfg['codechecker_cfg'],
self._test_workspace)
auth_token_client = \
env.setup_auth_client(self._test_workspace,
session_token=token)
# Log-in by using an already generated personal token.
self.sessionToken = auth_token_client.performLogin("Username:Password",
"cc:" + token)
self.assertIsNotNone(self.sessionToken,
"Valid credentials didn't give us a token!")
user = auth_token_client.getLoggedInUser()
self.assertEqual(user, "cc")
result = auth_token_client.destroySession()
self.assertTrue(result, "Server did not allow us to destroy session.")
# Kill the session token that was created by login() too.
codechecker.logout(self._test_cfg['codechecker_cfg'],
self._test_workspace)
self.sessionToken = auth_client.performLogin("Username:Password",
"cc:test")
self.assertIsNotNone(self.sessionToken,
"Valid credentials didn't give us a token!")
auth_client = env.setup_auth_client(self._test_workspace,
session_token=self.sessionToken)
# Remove the generated personal token.
ret = auth_client.removeToken(token)
self.assertTrue(ret)
# Check whether no more personal token in the database.
personal_tokens = auth_client.getTokens()
self.assertEqual(len(personal_tokens), 0)
result = auth_client.destroySession()
self.assertTrue(result, "Server did not allow us to destroy session.")
with self.assertRaises(TProtocolException):
# The server reports a HTTP 401 error which is not a valid
# Thrift response. But if it does so, it passes the test!
client.getPackageVersion()
print("Privileged client allowed access after logout.")
handshake = auth_client.getAuthParameters()
self.assertFalse(handshake.sessionStillActive,
"Destroyed session was " +
"reported to be still active.")
def test_privileged_access(self):
"""
Tests that initially, a non-authenticating server is accessible,
but an authenticating one is not.
"""
# Switch off certificate validation on the clients.
os.environ["OSPYTHONHTTPSVERIFY"] = '0'
# FIXME: change this to https
access_protocol = 'http'
auth_client = env.setup_auth_client(self._test_workspace,
session_token='_PROHIBIT',
proto=access_protocol)
handshake = auth_client.getAuthParameters()
self.assertTrue(handshake.requiresAuthentication,
"Privileged server " +
"did not report that it requires authentication.")
self.assertFalse(handshake.sessionStillActive, "Empty session was " +
"reported to be still active.")
with self.assertRaises(RequestFailed):
auth_client.performLogin("Username:Password", "invalid:invalid")
print("Invalid credentials gave us a token!")
# A non-authenticated session should return an empty user.
user = auth_client.getLoggedInUser()
self.assertEqual(user, "")
# We still need to create a product on the new server, because
# in PostgreSQL mode, the same database is used for configuration
# by the newly started instance of this test suite too.
codechecker.add_test_package_product(
self._test_cfg['codechecker_cfg'],
self._test_workspace,
# Use the test's home directory to find the session token file.
self._test_cfg['codechecker_cfg']['check_env'],
access_protocol)
self.sessionToken = auth_client.performLogin("Username:Password",
"cc:test")
self.assertIsNotNone(self.sessionToken,
"Valid credentials didn't give us a token!")
handshake = auth_client.getAuthParameters()
self.assertTrue(handshake.requiresAuthentication,
"Privileged server " +
"did not report that it requires authentication.")
self.assertFalse(handshake.sessionStillActive,
"Valid session was " + "reported not to be active.")
client = env.setup_viewer_client(self._test_workspace,
session_token=self.sessionToken,
proto=access_protocol)
self.assertIsNotNone(client.getPackageVersion(),
"Privileged server didn't respond properly.")
authd_auth_client = \
env.setup_auth_client(self._test_workspace,
session_token=self.sessionToken,
proto=access_protocol)
user = authd_auth_client.getLoggedInUser()
self.assertEqual(user, "cc")
auth_client = env.setup_auth_client(self._test_workspace,
session_token=self.sessionToken,
proto=access_protocol)
result = auth_client.destroySession()
self.assertTrue(result, "Server did not allow us to destroy session.")
# Kill the session token that was created by login() too.
codechecker.logout(self._test_cfg['codechecker_cfg'],
self._test_workspace,
access_protocol)
with self.assertRaises(TProtocolException):
# The server reports a HTTP 401 error which is not a valid
# Thrift response. But if it does so, it passes the test!
client.getPackageVersion()
print("Privileged client allowed access after logout.")
handshake = auth_client.getAuthParameters()
self.assertFalse(handshake.sessionStillActive,
"Destroyed session was " +
"reported to be still active.")
codechecker.remove_test_package_product(
self._test_workspace,
# Use the test's home directory to find the session token file.
self._test_cfg['codechecker_cfg']['check_env'],
access_protocol)
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()
