def start_server(codechecker_cfg, event):
"""Start the CodeChecker server."""
def start_server_proc(event, server_cmd, checking_env):
"""Target function for starting the CodeChecker server."""
proc = subprocess.Popen(server_cmd, env=checking_env)
# Blocking termination until event is set.
event.wait()
# If proc is still running, stop it.
if proc.poll() is None:
proc.terminate()
# The server is started in the same folder as the "master" one.
server_cmd = codechecker.serv_cmd(env.get_workspace(None),
str(codechecker_cfg['viewer_port']),
env.get_postgresql_cfg())
server_proc = multiprocessing.Process(name='server',
target=start_server_proc,
args=(event, server_cmd,
codechecker_cfg['check_env']))
server_proc.start()
# Wait for server to start and connect to database.
time.sleep(5)
def _start_server(codechecker_cfg, test_config, auth=False):
"""Start the CodeChecker server."""
def start_server_proc(event, server_cmd, checking_env):
"""Target function for starting the CodeChecker server."""
proc = subprocess.Popen(server_cmd, env=checking_env)
# Blocking termination until event is set.
event.wait()
# If proc is still running, stop it.
if proc.poll() is None:
proc.terminate()
server_cmd = codechecker.serv_cmd(codechecker_cfg['workspace'],
str(codechecker_cfg['viewer_port']),
env.get_postgresql_cfg())
server_proc = multiprocessing.Process(name='server',
target=start_server_proc,
args=(__STOP_SERVER, server_cmd,
codechecker_cfg['check_env']))
server_proc.start()
# Wait for server to start and connect to database.
time.sleep(20)
def setup_package():
"""Setup the environment for the tests then start the server."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('authentication')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project_path = project.path()
clang_version = env.clang_to_test()
pg_db_config = env.get_postgresql_cfg()
test_config = {}
project_info = project.get_info(project.path())
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
# Setup environment varaibled for the test cases.
host_port_cfg = env.get_host_port_cfg()
test_env = env.test_env()
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'pg_db_config': pg_db_config,
'checkers': []
}
codechecker_cfg.update(host_port_cfg)
codechecker_cfg['run_names'] = []
test_config['codechecker_cfg'] = codechecker_cfg
# Export configuration for the tests.
env.export_test_cfg(TEST_WORKSPACE, test_config)
# Enable authentication and start the CodeChecker server.
enable_auth(TEST_WORKSPACE)
print("Starting server to get results")
_start_server(codechecker_cfg, test_config, False)
def setup_package():
"""
Setup the environment for the report_server_api test.
"""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('report_server_api')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project_path = project.path()
pg_db_config = env.get_postgresql_cfg()
test_config = {}
suppress_file = None
skip_list_file = None
# Setup env vars for test cases.
host_port_cfg = env.get_host_port_cfg()
test_env = env.test_env()
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'pg_db_config': pg_db_config,
'checkers': []
}
codechecker_cfg.update(host_port_cfg)
test_config['codechecker_cfg'] = codechecker_cfg
# Export test configuration.
env.export_test_cfg(TEST_WORKSPACE, test_config)
# Start the CodeChecker server.
_start_server(codechecker_cfg, test_config, False)
def setup_package():
"""Setup the environment for testing delete_runs."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('delete_runs')
# Set the TEST_WORKSPACE used by the tests.
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
# PostgreSQL configuration might be empty if tests are run
# with SQLite.
pg_db_config = env.get_postgresql_cfg()
test_config = {}
test_project = 'simple'
project_info = project.get_info(test_project)
# Copy the test project to the workspace. The tests should
# work only on this test project.
test_proj_path = os.path.join(TEST_WORKSPACE, "test_proj")
shutil.copytree(project.path(test_project), test_proj_path)
project_info['project_path'] = test_proj_path
# Generate a unique name for this test run.
test_project_name = project_info['name']
test_config['test_project'] = project_info
# Suppress file should be set here if needed by the tests.
suppress_file = None
# Skip list file should be set here if needed by the tests.
skip_list_file = None
# Get an environment which should be used by the tests.
test_env = env.test_env()
# Create a basic CodeChecker config for the tests, this should
# be imported by the tests and they should only depend on these
# configuration options.
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'pg_db_config': pg_db_config,
'checkers': []
}
# Get new unique port numbers for this test run.
host_port_cfg = env.get_host_port_cfg()
# Extend the checker configuration with the port numbers.
codechecker_cfg.update(host_port_cfg)
# Start the CodeChecker server.
print("Starting server to get results")
_start_server(codechecker_cfg, test_config, False)
for i in range(0, 5):
# Clean the test project, if needed by the tests.
ret = project.clean(test_project)
if ret:
sys.exit(ret)
# Check the test project, if needed by the tests.
ret = codechecker.check(codechecker_cfg,
test_project_name + '_' + str(i),
test_proj_path)
if ret:
sys.exit(1)
print("Analyzing the test project was successful {}.".format(str(i)))
# If the check process is very fast, datetime of multiple runs can be
# almost the same different in microseconds. Test cases of delete runs
# can be failed for this reason because we didn't process microseconds
# in command line arguments.
time.sleep(1)
# Save the run names in the configuration.
codechecker_cfg['run_names'] \
= [test_project_name + '_' + str(i) for i in range(0, 5)]
test_config['codechecker_cfg'] = codechecker_cfg
# Export the test configuration to the workspace.
env.export_test_cfg(TEST_WORKSPACE, test_config)
def setup_package():
"""Setup the environment for the tests. """
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('update')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project_path = project.path()
clang_version = env.clang_to_test()
pg_db_config = env.get_postgresql_cfg()
test_config = {}
project_info = project.get_info(project.path())
test_project_path = os.path.join(TEST_WORKSPACE, "test_proj")
shutil.copytree(project.path(), test_project_path)
project_info['project_path'] = test_project_path
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
# Get port numbers for the tests.
host_port_cfg = env.get_host_port_cfg()
test_env = env.test_env()
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'pg_db_config': pg_db_config,
'checkers': []
}
codechecker_cfg.update(host_port_cfg)
ret = project.clean(test_project_path, test_env)
if ret:
sys.exit(ret)
ret = codechecker.check(codechecker_cfg, test_project_name,
test_project_path)
if ret:
sys.exit(1)
print("Analyzing test project was succcessful.")
if pg_db_config:
print("Waiting for PotgreSQL to stop.")
codechecker.wait_for_postgres_shutdown(TEST_WORKSPACE)
codechecker_cfg['run_names'] = [test_project_name]
test_config['codechecker_cfg'] = codechecker_cfg
env.export_test_cfg(TEST_WORKSPACE, test_config)
# Start the CodeChecker server.
print("Starting server to get results")
_start_server(codechecker_cfg, test_config, False)
def setup_package():
"""
Setup the environment for the tests.
Check the test project twice, then start the server.
"""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('diff')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project = 'cpp'
test_project_path = project.path(test_project)
pg_db_config = env.get_postgresql_cfg()
test_config = {}
project_info = project.get_info(test_project)
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
# Setup environment variabled for test cases.
host_port_cfg = env.get_host_port_cfg()
test_env = env.test_env()
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'reportdir': os.path.join(TEST_WORKSPACE, 'reports'),
'pg_db_config': pg_db_config,
'checkers':
['-d', 'core.CallAndMessage', '-e', 'core.StackAddressEscape']
}
codechecker_cfg.update(host_port_cfg)
test_config['codechecker_cfg'] = codechecker_cfg
ret = project.clean(test_project, test_env)
if ret:
sys.exit(ret)
# Start the CodeChecker server.
print("Starting server to get results")
_start_server(codechecker_cfg, test_config, False)
test_project_name_base = project_info['name'] + '_' + uuid.uuid4().hex
ret = codechecker.check(codechecker_cfg, test_project_name_base,
test_project_path)
if ret:
sys.exit(1)
print("First analysis of the test project was successful.")
ret = project.clean(test_project, test_env)
if ret:
sys.exit(ret)
test_project_name_new = project_info['name'] + '_' + uuid.uuid4().hex
# Let's run the second analysis with different
# checkers to have some real difference.
codechecker_cfg['checkers'] = [
'-e', 'core.CallAndMessage', '-d', 'core.StackAddressEscape'
]
ret = codechecker.check(codechecker_cfg, test_project_name_new,
test_project_path)
if ret:
sys.exit(1)
print("Second analysis of the test project was successful.")
# Run the second analysis results
# into a report directory
ret = codechecker.analyze(codechecker_cfg, test_project_name_new,
test_project_path)
if ret:
sys.exit(1)
print("CodeChecker analyze of test project was successful.")
if pg_db_config:
print("Waiting for PotgreSQL to stop.")
codechecker.wait_for_postgres_shutdown(TEST_WORKSPACE)
# Order of the test run names matter at comparison!
codechecker_cfg['run_names'] = [
test_project_name_base, test_project_name_new
]
test_config['codechecker_cfg'] = codechecker_cfg
# Export test configuration to the workspace.
env.export_test_cfg(TEST_WORKSPACE, test_config)
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, None, 0)
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})
server_config = dict(self.codechecker_cfg_2)
server_config['workspace'] = os.path.join(env.get_workspace(None),
'global_auth_server')
codechecker.start_server(server_config, EVENT, None,
env.get_postgresql_cfg())
# 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 setup_package():
"""Setup the environment for the tests. Check the test project twice,
then start the server."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('skip')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project = 'cpp'
pg_db_config = env.get_postgresql_cfg()
test_config = {}
project_info = project.get_info(test_project)
test_config['test_project'] = project_info
suppress_file = None
# Generate skip list file for the tests.
skip_list_file = os.path.join(TEST_WORKSPACE, 'skip_file')
if os.path.isfile(skip_list_file):
os.remove(skip_list_file)
_generate_skip_list_file(skip_list_file)
# Get port numbers for the tests.
host_port_cfg = env.get_host_port_cfg()
test_env = env.test_env()
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'pg_db_config': pg_db_config,
'checkers': []
}
codechecker_cfg.update(host_port_cfg)
ret = project.clean(test_project, test_env)
if ret:
sys.exit(ret)
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex
ret = codechecker.check(codechecker_cfg, test_project_name,
project.path(test_project))
if ret:
sys.exit(1)
print("Analyzing the test project was successful.")
if pg_db_config:
print("Waiting for PostgreSQL to stop.")
codechecker.wait_for_postgres_shutdown(TEST_WORKSPACE)
codechecker_cfg['run_names'] = [test_project_name]
test_config['codechecker_cfg'] = codechecker_cfg
env.export_test_cfg(TEST_WORKSPACE, test_config)
# Start the CodeChecker server.
print("Starting server to get results.")
_start_server(codechecker_cfg, test_config, False)
def setup_package():
"""Setup the environment for the tests. Then start the server."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('report_viewer_api')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project = 'cpp'
pg_db_config = env.get_postgresql_cfg()
test_config = {}
project_info = project.get_info(test_project)
test_proj_path = os.path.join(TEST_WORKSPACE, "test_proj")
shutil.copytree(project.path(test_project), test_proj_path)
project_info['project_path'] = test_proj_path
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
# Get port numbers for the tests.
host_port_cfg = env.get_host_port_cfg()
test_env = env.test_env()
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'pg_db_config': pg_db_config,
'checkers': []
}
codechecker_cfg.update(host_port_cfg)
ret = project.clean(test_project)
if ret:
sys.exit(ret)
print("Starting server to get results.")
_start_server(codechecker_cfg, test_config, False)
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex
ret = codechecker.check(codechecker_cfg, test_project_name,
project.path(test_project))
if ret:
sys.exit(1)
print("Analyzing the test project was successful.")
codechecker_cfg['run_names'] = [test_project_name]
test_config['codechecker_cfg'] = codechecker_cfg
env.export_test_cfg(TEST_WORKSPACE, test_config)
def setup_package():
"""Setup the environment for testing $TEST_NAME$."""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('$TEST_NAME$')
# Set the TEST_WORKSPACE used by the tests.
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
# Get the clang version which is used for testing.
# Important because different clang releases might
# find different errors.
clang_version = env.clang_to_test()
# PostgreSQL configuration might be empty if tests are run
# with SQLite.
pg_db_config = env.get_postgresql_cfg()
test_config = {}
project_info = project.get_info(project.path())
# Copy the test project to the workspace. The tests should
# work only on this test project.
test_proj_path = os.path.join(TEST_WORKSPACE, "test_proj")
shutil.copytree(project.path(), test_proj_path)
project_info['project_path'] = test_proj_path
# Generate a unique name for this test run.
test_project_name = project_info['name'] + '_' + uuid.uuid4().hex
test_config['test_project'] = project_info
# Suppress file should be set here if needed by the tests.
suppress_file = None
# Skip list file should be set here if needed by the tests.
skip_list_file = None
# Get an environment which should be used by the tests.
test_env = env.test_env()
# Create a basic CodeChecker config for the tests, this should
# be imported by the tests and they should only depend on these
# configuration options.
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'pg_db_config': pg_db_config,
'checkers': []
}
# Get new unique port numbers for this test run.
host_port_cfg = env.get_host_port_cfg()
# Extend the checker configuration with the port numbers.
codechecker_cfg.update(host_port_cfg)
# Clean the test project, if needed by the tests.
ret = project.clean(project.path())
if ret:
sys.exit(ret)
# Check the test project, if needed by the tests.
ret = codechecker.check(codechecker_cfg,
test_project_name,
project.path())
if ret:
sys.exit(1)
print("Analyzing the test project was successful.")
if pg_db_config:
print("Waiting for PostgreSQL to stop.")
codechecker.wait_for_postgres_shutdown(TEST_WORKSPACE)
# Save the run names in the configuration.
codechecker_cfg['run_names'] = [test_project_name]
test_config['codechecker_cfg'] = codechecker_cfg
# Export the test configuration to the workspace.
env.export_test_cfg(TEST_WORKSPACE, test_config)
# Start the CodeChecker server.
print("Starting server to get results")
_start_server(codechecker_cfg, test_config, False)
def setup_package():
"""
Setup the environment for the tests.
Check the test project twice, then start the server.
"""
global TEST_WORKSPACE
TEST_WORKSPACE = env.get_workspace('diff')
os.environ['TEST_WORKSPACE'] = TEST_WORKSPACE
test_project_path = project.path()
clang_version = env.clang_to_test()
pg_db_config = env.get_postgresql_cfg()
test_config = {}
project_info = project.get_info(project.path())
test_config['test_project'] = project_info
suppress_file = None
skip_list_file = None
# Setup environment variabled for test cases.
host_port_cfg = env.get_host_port_cfg()
test_env = env.test_env()
codechecker_cfg = {
'suppress_file': suppress_file,
'skip_list_file': skip_list_file,
'check_env': test_env,
'workspace': TEST_WORKSPACE,
'pg_db_config': pg_db_config,
'checkers': []
}
codechecker_cfg.update(host_port_cfg)
test_config['codechecker_cfg'] = codechecker_cfg
ret = project.clean(test_project_path, test_env)
if ret:
sys.exit(ret)
test_project_name_base = project_info['name'] + '_' + uuid.uuid4().hex
ret = codechecker.check(codechecker_cfg, test_project_name_base,
test_project_path)
if ret:
sys.exit(1)
print("First analysis of the test project was successful.")
if pg_db_config:
print("Waiting for PotgreSQL to stop.")
codechecker.wait_for_postgres_shutdown(TEST_WORKSPACE)
ret = project.clean(test_project_path, test_env)
if ret:
sys.exit(ret)
test_project_name_new = project_info['name'] + '_' + uuid.uuid4().hex
ret = codechecker.check(codechecker_cfg, test_project_name_new,
test_project_path)
if ret:
sys.exit(1)
print("Second analysis of the test project was successful.")
if pg_db_config:
print("Waiting for PotgreSQL to stop.")
codechecker.wait_for_postgres_shutdown(TEST_WORKSPACE)
# Order of the test run names matter at comparison!
codechecker_cfg['run_names'] = [
test_project_name_base, test_project_name_new
]
test_config['codechecker_cfg'] = codechecker_cfg
# Export test configuration to the workspace.
env.export_test_cfg(TEST_WORKSPACE, test_config)
# Start the CodeChecker server.
print("Starting server to get results")
_start_server(codechecker_cfg, test_config, False)
