From e869ab7ff78edf45d4e0d700bd640dfa6be70a30 Mon Sep 17 00:00:00 2001 From: Thyagarajan Balakrishnan Date: Fri, 14 Oct 2011 11:43:12 +0300 Subject: [PATCH] Changes: Merge 'fangorn/my-re-exec' - updated test cases with sighup RevBy: Olli, Marek --- tests/harmattan/testscripts/test-daemons.py | 39 +++- .../testscripts/test-func-launcher.py | 194 +++++++++++------- tests/harmattan/testscripts/test-invoker.py | 98 +++++++-- .../testscripts/test-single-instance.py | 73 ++++--- tests/harmattan/testscripts/utils.py | 31 ++- 5 files changed, 312 insertions(+), 123 deletions(-) diff --git a/tests/harmattan/testscripts/test-daemons.py b/tests/harmattan/testscripts/test-daemons.py index 23a9a55..1b108b6 100644 --- a/tests/harmattan/testscripts/test-daemons.py +++ b/tests/harmattan/testscripts/test-daemons.py @@ -31,12 +31,21 @@ class DaemonTests(unittest.TestCase): def tearDown(self): debug("tearDown") - def test_launcher_exist(self): + def sighup_applauncherd(self): + same_pid, booster_status = send_sighup_to_applauncherd() + self.assert_(same_pid, "Applauncherd has new pid after SIGHUP") + self.assert_(booster_status, "Atleast one of the boosters is not restarted") + + def test_launcher_exist(self, sighup = True): """ To test if the launcher exists and is executable or not """ self.assert_(os.path.isfile(LAUNCHER_BINARY), "Launcher file does not exist") self.assert_(os.access(LAUNCHER_BINARY, os.X_OK), "Launcher exists, but is not executable") + + if(sighup): + self.sighup_applauncherd() + self.test_launcher_exist(False) def test_daemon_list(self): """ @@ -93,7 +102,7 @@ class DaemonTests(unittest.TestCase): start_applauncherd() - def test_daemon_second_instance(self): + def test_daemon_second_instance(self, sighup = True): """ Test that second instance of applauncherd cannot be started """ @@ -108,7 +117,11 @@ class DaemonTests(unittest.TestCase): self.assert_(daemon_pid == daemon_pid_new, "New instance of applauncherd started") self.assert_(st != 0, "Second instance of applauncherd started") - def test_writable_executable_mem(self): + if(sighup): + self.sighup_applauncherd() + self.test_daemon_second_instance(False) + + def test_writable_executable_mem(self, sighup = True): """ Test that applauncherd does not have the writable and executable memory """ @@ -118,12 +131,22 @@ class DaemonTests(unittest.TestCase): debug("The value of status is %d" %st) debug("The value of output is %s" %op) self.assert_(st != 0, "applauncherd has writable and executable memory") + + if(sighup): + self.sighup_applauncherd() + self.test_writable_executable_mem(False) - def test_applauncherd_fd_close(self): + def test_applauncherd_fd_close(self, sighup = True): self._test_applauncherd_fd() + if(sighup): + self.sighup_applauncherd() + self.test_applauncherd_fd_close(False) - def test_applauncherd_fd_kill(self): + def test_applauncherd_fd_kill(self, sighup = True): self._test_applauncherd_fd(False) + if(sighup): + self.sighup_applauncherd() + self.test_applauncherd_fd_kill(False) def _test_applauncherd_fd(self, close = True): """ @@ -218,7 +241,7 @@ class DaemonTests(unittest.TestCase): self.assert_(op == 'FATAL!!: DISPLAY environment variable not set.',\ "Applauncherd was started even when DISPLAY was not set") - def test_app_exits_clean(self): + def test_app_exits_clean(self, sighup = True): """ Test that a test applications exits clean. """ @@ -239,7 +262,9 @@ class DaemonTests(unittest.TestCase): launcher_pid_new = wait_for_single_applauncherd self.assert_(launcher_pid == launcher_pid_new, "The Pid of applauncherd has changed") - + if(sighup): + self.sighup_applauncherd() + self.test_app_exits_clean(False) if __name__ == '__main__': diff --git a/tests/harmattan/testscripts/test-func-launcher.py b/tests/harmattan/testscripts/test-func-launcher.py index 12006c4..768f1c3 100644 --- a/tests/harmattan/testscripts/test-func-launcher.py +++ b/tests/harmattan/testscripts/test-func-launcher.py @@ -107,6 +107,11 @@ class launcher_tests (unittest.TestCase): if self.START_DAEMONS_AT_TEARDOWN: start_daemons() + def sighup_applauncherd(self): + same_pid, booster_status = send_sighup_to_applauncherd() + self.assert_(same_pid, "Applauncherd has new pid after SIGHUP") + self.assert_(booster_status, "Atleast one of the boosters is not restarted") + #Testcases def test_applications_exist(self): @@ -140,7 +145,7 @@ class launcher_tests (unittest.TestCase): def test_zombie_state_e(self): self._test_zombie_state(PREFERED_APP, 'e') - def _test_zombie_state(self, prefered_app, btype): + def _test_zombie_state(self, prefered_app, btype, sighup = True): """ To test that no Zombie process exist after the application is killed """ @@ -167,6 +172,9 @@ class launcher_tests (unittest.TestCase): self.assert_(process_id != process_id1 , "New Process not launched") self.assert_(process_id1 == None , "Process still running") + if(sighup): + self.sighup_applauncherd() + self._test_zombie_state(prefered_app, btype, False) def test_launch_multiple_apps_m(self): self._test_launch_multiple_apps(LAUNCHABLE_APPS, 'm') @@ -177,7 +185,7 @@ class launcher_tests (unittest.TestCase): def test_launch_multiple_apps_e(self): self._test_launch_multiple_apps(LAUNCHABLE_APPS, 'e') - def _test_launch_multiple_apps(self, launchable_apps, btype): + def _test_launch_multiple_apps(self, launchable_apps, btype, sighup = True): """ To test that more than one applications are launched by the launcher """ @@ -199,6 +207,9 @@ class launcher_tests (unittest.TestCase): pidlist.append(pid) kill_launched(pidlist) self.assert_(len(pidlist) == len(launchable_apps),"All apps were not launched") + if(sighup): + self.sighup_applauncherd() + self._test_launch_multiple_apps(launchable_apps, btype, False) def test_one_instance_m(self): self._test_one_instance(PREFERED_APP, 'm') @@ -209,7 +220,7 @@ class launcher_tests (unittest.TestCase): def test_one_instance_e(self): self._test_one_instance(PREFERED_APP, 'e') - def _test_one_instance(self, prefered_app, btype): + def _test_one_instance(self, prefered_app, btype, sighup = True): """ To test that only one instance of a application exist """ @@ -233,6 +244,9 @@ class launcher_tests (unittest.TestCase): kill_process(prefered_app) self.assert_( len(process_id.split(' ')) == 1, "Only one instance of app not running") + if(sighup): + self.sighup_applauncherd() + self._test_one_instance(prefered_app, btype, False) def test_launch_multiple_apps_cont_m(self): self._test_launch_multiple_apps_cont(LAUNCHABLE_APPS, 'fala_ft_hello', 'm') @@ -243,7 +257,7 @@ class launcher_tests (unittest.TestCase): def test_launch_multiple_apps_cont_e(self): self._test_launch_multiple_apps_cont(LAUNCHABLE_APPS, 'fala_ft_hello', 'e') - def _test_launch_multiple_apps_cont(self, launchable_apps, app_common_prefix, btype): + def _test_launch_multiple_apps_cont(self, launchable_apps, app_common_prefix, btype, sighup = True): """ To test that more than one applications are launched by the launcher """ @@ -262,37 +276,52 @@ class launcher_tests (unittest.TestCase): kill_process(apppid=pid) self.assert_(len(pid_list) == len(launchable_apps), "All Applications were not launched using launcher") + if(sighup): + self.sighup_applauncherd() + self._test_launch_multiple_apps_cont(launchable_apps, app_common_prefix, btype, False) - def test_fd_booster_m(self): + def test_fd_booster_m(self, sighup = True): """ File descriptor test for booster-m """ count = get_file_descriptor("booster-m", "m", "fala_ft_hello") self.assert_(count != 0, "None of the file descriptors were changed") + if(sighup): + self.sighup_applauncherd() + self.test_fd_booster_m(False) - def test_fd_booster_q(self): + def test_fd_booster_q(self, sighup = True): """ File descriptor test for booster-q """ count = get_file_descriptor("booster-q", "qt", "fala_ft_hello") self.assert_(count != 0, "None of the file descriptors were changed") + if(sighup): + self.sighup_applauncherd() + self.test_fd_booster_q(False) - def test_fd_booster_d(self): + def test_fd_booster_d(self, sighup = True): """ File descriptor test for booster-d """ count = get_file_descriptor("booster-d", "d", "fala_qml_helloworld") self.assert_(count != 0, "None of the file descriptors were changed") + if(sighup): + self.sighup_applauncherd() + self.test_fd_booster_d(False) - def test_fd_booster_e(self): + def test_fd_booster_e(self, sighup = True): """ File descriptor test for booster-e """ count = get_file_descriptor("booster-e", "e", "fala_ft_hello") self.assert_(count != 0, "None of the file descriptors were changed") + if(sighup): + self.sighup_applauncherd() + self.test_fd_booster_e(False) - def test_restart_booster(self): + def test_restart_booster(self, sighup = True): """ Test that booster is restarted if it is killed """ @@ -339,6 +368,10 @@ class launcher_tests (unittest.TestCase): self.assert_(epid_new != None, "No booster process running") self.assert_(epid_new != epid, "booster process was not killed") + if(sighup): + self.sighup_applauncherd() + self.test_restart_booster(False) + def test_booster_killed_or_restarted(self): """ Test that boosters are killed if applauncherd is stopped @@ -434,8 +467,8 @@ class launcher_tests (unittest.TestCase): self.assert_(len(epid_new.split("\n")) == 1, "multiple instances of booster-e running") self.assert_(epid_new != None, "No booster process running") self.assert_(epid_new != epid, "booster process was not killed") - - def test_booster_pid_change(self): + + def test_booster_pid_change(self, sighup = True): """ Test that application pid changes to the booster 'x' when application is started with invoker --type='x' @@ -489,6 +522,10 @@ class launcher_tests (unittest.TestCase): self.assert_(qpid_new != None, "No booster process running") self.assert_(qpid_new != qpid, "booster-q process did not receive the new pid") + if(sighup): + self.sighup_applauncherd() + self.test_booster_pid_change(False) + def test_stress_boosted_apps(self): self._test_stress_boosted_apps('m', 'fala_ft_hello') @@ -498,7 +535,7 @@ class launcher_tests (unittest.TestCase): self._test_stress_boosted_apps('e', 'fala_ft_hello') time.sleep(5) - def _test_stress_boosted_apps(self, booster_type, app_name, invoker_extra_flags=''): + def _test_stress_boosted_apps(self, booster_type, app_name, invoker_extra_flags='', sighup = True): """ Stress test for boosted applications to check only one instance is running. """ @@ -524,8 +561,11 @@ class launcher_tests (unittest.TestCase): self.assert_(pid == app_pid, "Same instance of application not running") st, op = commands.getstatusoutput('ps ax | grep invoker | grep %s| grep -v -- -sh | wc -l' % app_name) count = int(op) + if(sighup): + self.sighup_applauncherd() + self._test_stress_boosted_apps(booster_type, app_name, invoker_extra_flags, False) - def test_launched_app_name(self): + def test_launched_app_name(self, sighup = True): """ Test that launched application have correct applicationname """ @@ -585,11 +625,14 @@ class launcher_tests (unittest.TestCase): kill_process('fala_wl') self.assert_(op1.split(",")[0] == '"fala_wl"','Application name is incorrect') + if(sighup): + self.sighup_applauncherd() + self.test_launched_app_name(False) - def test_unix_signal_handlers(self): + def test_unix_signal_handlers(self, sighup = True): """ - Test unixSignalHAndlers by killing booster-m and booster-d, singnal hub + Test unixSignalHandlers by killing booster-m and booster-d, signal hup """ mpid = get_pid('booster-m') @@ -605,13 +648,17 @@ class launcher_tests (unittest.TestCase): dpid_new = wait_for_app('booster-d') self.assert_(dpid != dpid_new, "booster-d pid is not changed") + if(sighup): + self.sighup_applauncherd() + self.test_unix_signal_handlers(False) + def test_qttas_load_booster_d(self): self._test_qttas_load_booster(PREFERED_APP_QML, 'd') def test_qttas_load_booster_m(self): self._test_qttas_load_booster(PREFERED_APP, 'm') - def _test_qttas_load_booster(self, testapp, btype): + def _test_qttas_load_booster(self, testapp, btype, sighup = True): """ To test invoker that qttestability plugin is loaded with -testability argument for booster-d """ @@ -638,13 +685,17 @@ class launcher_tests (unittest.TestCase): time.sleep(2) + if(sighup): + self.sighup_applauncherd() + self._test_qttas_load_booster(testapp, btype, False) + def test_qttas_load_env_booster_d(self): self._test_qttas_load_env_booster(PREFERED_APP_QML, 'd') def test_qttas_load_env_booster_m(self): self._test_qttas_load_env_booster(PREFERED_APP, 'm') - def _test_qttas_load_env_booster(self, testapp, btype): + def _test_qttas_load_env_booster(self, testapp, btype, sighup = True): """ To test invoker that qttestability plugin is loaded with QT_LOAD_TESTABILITY env variable for booster-d """ @@ -676,6 +727,10 @@ class launcher_tests (unittest.TestCase): time.sleep(2) + if(sighup): + self.sighup_applauncherd() + self._test_qttas_load_env_booster(testapp, btype, False) + def test_dirPath_filePath_m(self): self._test_dirPath_filePath('m', "/usr/share/fala_images", "fala_hello") @@ -689,7 +744,7 @@ class launcher_tests (unittest.TestCase): def test_dirPath_filePath_e(self): self._test_dirPath_filePath('e', "/usr/share/fala_images", "fala_qml_helloworld") - def _test_dirPath_filePath(self, btype, path, testapp): + def _test_dirPath_filePath(self, btype, path, testapp, sighup = True): """ Test that correct file path and dir path is passed """ @@ -708,6 +763,10 @@ class launcher_tests (unittest.TestCase): filepath = op.split("\n")[1].split(" ")[2] kill_process(apppid=pid) self.assert_(filepath == "%s/%s" % (path, testapp), "Wrong filePath: %s" % filepath) + + if(sighup): + self.sighup_applauncherd() + self._test_dirPath_filePath(btype, path, testapp, False) def test_argv_mbooster_limit(self): self._test_argv_booster_limit("m", "fala_wl") @@ -715,7 +774,7 @@ class launcher_tests (unittest.TestCase): def test_argv_dbooster_limit(self): self._test_argv_booster_limit("d", "fala_qml_helloworld") - def _test_argv_booster_limit(self, btype, testapp): + def _test_argv_booster_limit(self, btype, testapp, sighup = True): """ Test that ARGV_LIMIT (32) arguments are successfully passed to cached [QM]Application. """ @@ -734,13 +793,17 @@ class launcher_tests (unittest.TestCase): kill_process(apppid=pid) self.assert_(original_argv == cache_argv, "Wrong arguments passed.\nOriginal: %s\nCached: %s" % (original_argv, cache_argv)) + if(sighup): + self.sighup_applauncherd() + self._test_argv_booster_limit(btype, testapp, False) + def test_argv_mbooster_over_limit(self): self._test_argv_booster_over_limit("m", "fala_wl") def test_argv_dbooster_over_limit(self): self._test_argv_booster_over_limit("d", "fala_qml_helloworld") - def _test_argv_booster_over_limit(self, btype, testapp): + def _test_argv_booster_over_limit(self, btype, testapp, sighup = True): """ Test that if more than ARGV_LIMIT (32) arguments are passed to cached [QM]Application, the application is still launched and ARGV_LIMIT arguments are successfully passed. @@ -763,6 +826,10 @@ class launcher_tests (unittest.TestCase): for i in range(ARGV_LIMIT): self.assert_(original_argv[i] == cache_argv[i], "Wrong arguments passed.\nOriginal: %s\nCached: %s" % (original_argv, cache_argv)) + if(sighup): + self.sighup_applauncherd() + self._test_argv_booster_over_limit(btype, testapp, False) + def test_signal_status_m(self): self._test_signal_status("fala_wl", "fala_wol") @@ -915,72 +982,57 @@ class launcher_tests (unittest.TestCase): def test_q_booster_dont_have_GL_context(self): - qpid = get_pid('booster-q') - self.assert_(qpid != None, "Process 'booster-q' is not running") - self.assert_(not has_GL_context(qpid), "booster-q has GL context!") + self._test_booster_dont_have_glcontext('q') def test_m_booster_dont_have_GL_context(self): - mpid = get_pid('booster-m') - self.assert_(mpid != None, "Process 'booster-m' is not running") - self.assert_(not has_GL_context(mpid), "booster-m has GL context!") + self._test_booster_dont_have_glcontext('m') def test_e_booster_dont_have_GL_context(self): - epid = get_pid('booster-e') - self.assert_(epid != None, "Process 'booster-e' is not running") - self.assert_(not has_GL_context(epid), "booster-e has GL context!") + self._test_booster_dont_have_glcontext('e') def test_d_booster_dont_have_GL_context(self): - dpid = get_pid('booster-d') - self.assert_(dpid != None, "Process 'booster-d' is not running") - self.assert_(not has_GL_context(dpid), "booster-d has GL context!") - + self._test_booster_dont_have_glcontext('d') + + def _test_booster_dont_have_glcontext(self, btype, sighup = True): + pid = get_pid('booster-%s'%btype) + self.assert_(pid != None, "Process 'booster-%s' is not running"%btype) + self.assert_(not has_GL_context(pid), "booster-%s has GL context!"%btype) + if(sighup): + self.sighup_applauncherd() + self._test_booster_dont_have_glcontext(btype, False) + def test_q_boosted_has_glcontext(self): - qpid = get_pid('booster-q') - self.assert_(qpid != None, "Process 'booster-q' is not running") - self.assert_(not has_GL_context(qpid), "booster-q has GL context!") - p = run_app_as_user_with_invoker(PREFERED_APP, booster = 'q', arg = '--no-wait') - time.sleep(4) - app_pid = get_pid('fala_ft_hello') - self.assert_(app_pid != None, "Process 'fala_ft_hello' is not running") - glcontext = has_GL_context(app_pid) - kill_process('fala_ft_hello') - self.assert_(glcontext, "fala_ft_hello does not have GL context!") + self._test_boosted_app_has_glcontext(PREFERED_APP, 'q') def test_m_boosted_has_glcontext(self): - mpid = get_pid('booster-m') - self.assert_(mpid != None, "Process 'booster-m' is not running") - self.assert_(not has_GL_context(mpid), "booster-m has GL context!") - p = run_app_as_user_with_invoker(PREFERED_APP, booster = 'm', arg = '--no-wait') - time.sleep(4) - app_pid = get_pid('fala_ft_hello') - self.assert_(app_pid != None, "Process 'fala_ft_hello' is not running") - glcontext = has_GL_context(app_pid) - kill_process('fala_ft_hello') - self.assert_(glcontext, "fala_ft_hello does not have GL context!") + self._test_boosted_app_has_glcontext(PREFERED_APP, 'm') def test_e_boosted_has_glcontext(self): - epid = get_pid('booster-e') - self.assert_(epid != None, "Process 'booster-e' is not running") - self.assert_(not has_GL_context(epid), "booster-e has GL context!") - p = run_app_as_user_with_invoker(PREFERED_APP, booster = 'e', arg = '--no-wait') - time.sleep(4) - app_pid = get_pid('fala_ft_hello') - self.assert_(app_pid != None, "Process 'fala_ft_hello' is not running") - glcontext = has_GL_context(app_pid) - kill_process('fala_ft_hello') - self.assert_(glcontext, "fala_ft_hello does not have GL context!") + self._test_boosted_app_has_glcontext(PREFERED_APP, 'e') def test_d_boosted_has_glcontext(self): - dpid = get_pid('booster-d') - self.assert_(dpid != None, "Process 'booster-d' is not running") - self.assert_(not has_GL_context(dpid), "booster-d has GL context!") - p = run_app_as_user_with_invoker(PREFERED_APP_QML, booster = 'd', arg = '--no-wait') + self._test_boosted_app_has_glcontext(PREFERED_APP_QML, 'd') + + def _test_boosted_app_has_glcontext(self, testapp, btype, sighup = True): + #check booster does not have GL context + booster_pid = get_pid('booster-%s'%btype) + self.assert_(booster_pid != None, "Process 'booster-%s' is not running"%btype) + self.assert_(not has_GL_context(booster_pid), "booster-%s has GL context!"%btype) + + # run app which has GL context + p = run_app_as_user_with_invoker(testapp, booster = btype, arg = '--no-wait') time.sleep(4) - app_pid = get_pid('fala_qml_helloworld') - self.assert_(app_pid != None, "Process 'fala_qml_helloworld' is not running") + app_pid = get_pid(testapp) + self.assert_(app_pid != None, "Process '%s' is not running"%testapp) + self.assert_(app_pid == booster_pid, "Process '%s' is not a boosted app"%testapp) + + #check if app has GL context glcontext = has_GL_context(app_pid) - kill_process('fala_qml_helloworld') - self.assert_(glcontext, "fala_qml_helloworld does not have GL context!") + kill_process(apppid=app_pid) + self.assert_(glcontext, "%s does not have GL context!"%testapp) + if(sighup): + self.sighup_applauncherd() + self._test_boosted_app_has_glcontext(testapp, btype, False) # detects bug def test_detect_booster_m_leaks_file_descriptor_when_invoker_is_using_app_directly(self) : diff --git a/tests/harmattan/testscripts/test-invoker.py b/tests/harmattan/testscripts/test-invoker.py index 74c5481..4ef16f8 100644 --- a/tests/harmattan/testscripts/test-invoker.py +++ b/tests/harmattan/testscripts/test-invoker.py @@ -51,15 +51,29 @@ class InvokerTests(unittest.TestCase): if self.START_DAEMONS_AT_TEARDOWN: start_daemons() + def sighup_applauncherd(self): + same_pid, booster_status = send_sighup_to_applauncherd() + self.assert_(same_pid, "Applauncherd has new pid after SIGHUP") + self.assert_(booster_status, "Atleast one of the boosters is not restarted") + #Testcases - def test_wait_term_m(self): + def test_wait_term_m(self, sighup = True): self._test_wait_term('/usr/bin/fala_ft_hello', 'fala_ft_hello', 'm') + if(sighup): + self.sighup_applauncherd() + self.test_wait_term_m(False) - def test_wait_term_qml(self): + def test_wait_term_qml(self, sighup = True): self._test_wait_term('/usr/bin/fala_qml_helloworld', 'fala_qml_helloworld', 'd') + if(sighup): + self.sighup_applauncherd() + self.test_wait_term_qml(False) - def test_wait_term_e(self): + def test_wait_term_e(self, sighup = True): self._test_wait_term('/usr/bin/fala_ft_hello', 'fala_ft_hello', 'e') + if(sighup): + self.sighup_applauncherd() + self.test_wait_term_e(False) def _test_wait_term(self, app_path, app_name, btype): """ @@ -123,7 +137,7 @@ class InvokerTests(unittest.TestCase): start_applauncherd() - def test_signal_forwarding(self): + def test_signal_forwarding(self, sighup = True): """ To test that invoker is killed by the same signal as the application """ @@ -163,9 +177,13 @@ class InvokerTests(unittest.TestCase): self.assert_(op.split('\n')[-1].startswith('Aborted') == True, "The invoker(q-booster) was not killed by the same signal") time.sleep(2) + + if(sighup): + self.sighup_applauncherd() + self.test_signal_forwarding(False) - def test_invoker_delay(self): + def test_invoker_delay(self, sighup = True): """ Test the --delay parameter of the invoker. """ @@ -197,7 +215,11 @@ class InvokerTests(unittest.TestCase): self.assert_(success, "invoker terminated before delay elapsed") - def test_invoker_exit_status(self): + if(sighup): + self.sighup_applauncherd() + self.test_invoker_delay(False) + + def test_invoker_exit_status(self, sighup = True): """ To test that invoker returns the same exit status as the application """ @@ -222,7 +244,11 @@ class InvokerTests(unittest.TestCase): self.assert_(app_st_wo_inv == app_st_w_inv, "The invoker returns a wrong exit status for booster-m") self.assert_(app_st_wo_inv == app_st_we_inv, "The invoker returns a wrong exit status for booster-e") - def test_invoker_search_prog(self): + if(sighup): + self.sighup_applauncherd() + self.test_invoker_exit_status(False) + + def test_invoker_search_prog(self, sighup = True): """ Test that invoker can find programs from directories listed in PATH environment variable and that it doesn't find something @@ -249,8 +275,12 @@ class InvokerTests(unittest.TestCase): self.assert_(p.wait() != 127, "Found spam_cakefor some reason") time.sleep(2) kill_process('spam_cake') + + if(sighup): + self.sighup_applauncherd() + self.test_invoker_search_prog(False) - def test_invoker_gid_uid(self): + def test_invoker_gid_uid(self, sighup = True): """ To Test that the set gid and uid is passed from invoker process to launcher """ @@ -312,13 +342,17 @@ class InvokerTests(unittest.TestCase): self.assert_(usr_id == usr_id2, "The correct UID is not passed by invoker") self.assert_(grp_id == grp_id2, "The correct GID is not passed by invoker") + + if(sighup): + self.sighup_applauncherd() + self.test_invoker_gid_uid(False) def test_invoker_param_creds(self): p = run_cmd_as_user('invoker --creds') self.assert_(p.wait() == 0, "'invoker --creds' failed") - def test_invoker_param_respawn_delay(self): + def test_invoker_param_respawn_delay(self, sighup = True): p = run_cmd_as_user('invoker --respawn 10 --type=q --no-wait fala_ft_hello') time.sleep(7) @@ -335,6 +369,10 @@ class InvokerTests(unittest.TestCase): self.assert_(p.wait() != 0, "invoker didn't die with too big respawn delay") kill_process('fala_ft_hello') + if(sighup): + self.sighup_applauncherd() + self.test_invoker_param_respawn_delay(False) + def test_invoker_bogus_apptype(self): p = run_cmd_as_user('invoker --type=foobar fala_ft_hello') self.assert_(p.wait() != 0, "invoker didn't die with bogus apptype") @@ -342,7 +380,7 @@ class InvokerTests(unittest.TestCase): p = run_cmd_as_user('invoker fala_ft_hello') self.assert_(p.wait() != 0, "invoker didn't die with empty apptype") - def test_invoker_signal_forward(self): + def test_invoker_signal_forward(self, sighup = True): """ Test that UNIX signals are forwarded from invoker to the invoked process @@ -354,6 +392,10 @@ class InvokerTests(unittest.TestCase): self.assert_(op.startswith('Segmentation fault') == True, "The invoker(m-booster) was not killed by the same signal") time.sleep(2) + if(sighup): + self.sighup_applauncherd() + self.test_invoker_signal_forward(False) + def test_wrong_type(self): """ Test that invoker help is printed if application is @@ -411,7 +453,7 @@ class InvokerTests(unittest.TestCase): p = run_cmd_as_user('invoker') self.assert_(p.wait() == 1, "'invoker' failed") - def test_app_link(self): + def test_app_link(self, sighup = True): """ Test that symlink of an application can be launched. """ @@ -424,7 +466,11 @@ class InvokerTests(unittest.TestCase): kill_process("fala_link") self.assert_(pid != None ,"The application was not launched") - def test_D_and_G_option(self): + if(sighup): + self.sighup_applauncherd() + self.test_app_link(False) + + def test_D_and_G_option(self, sighup = True): """ Test that -D and -G options work and applications are launcherd -G = INVOKER_MSG_MAGIC_OPTION_DLOPEN_GLOBAL @@ -442,7 +488,11 @@ class InvokerTests(unittest.TestCase): kill_process("fala_wl") self.assert_(pid != None ,"The application was not launched") - def test_app_directory(self): + if(sighup): + self.sighup_applauncherd() + self.test_D_and_G_option(False) + + def test_app_directory(self, sighup = True): """ Test that invoker is unable to launch a application which is a directory """ @@ -453,6 +503,10 @@ class InvokerTests(unittest.TestCase): os.system("rm -rf /usr/bin/fala_dir") self.assert_(st != 0 ,"The application was not launched") + if(sighup): + self.sighup_applauncherd() + self.test_app_directory(False) + def test_unsetPATH_launch(self): """ Unset the PATH env variable and try to launch an application with @@ -462,7 +516,7 @@ class InvokerTests(unittest.TestCase): self.assert_(st != 0, "The application was launched") self.assert_(op == "invoker: died: could not get PATH environment variable", "The application was launched") - def test_invoker_wait_term(self): + def test_invoker_wait_term(self, sighup = True): """ start application with --wait-term parameter. Check that application is started and invoker is waiting termination before exit @@ -494,7 +548,11 @@ class InvokerTests(unittest.TestCase): self.assert_(success, "invoker terminated before delay elapsed") - def test_relative_path_search(self): + if(sighup): + self.sighup_applauncherd() + self.test_invoker_wait_term(False) + + def test_relative_path_search(self, sighup = True): """ Test that invoker searches the application through relative path """ @@ -503,7 +561,11 @@ class InvokerTests(unittest.TestCase): kill_process("fala_wl") self.assert_(pid != None ,"The application was not launched") - def test_oom_adj_minus_two(self): + if(sighup): + self.sighup_applauncherd() + self.test_relative_path_search(False) + + def test_oom_adj_minus_two(self, sighup = True): """ Test that oom.adj is -2 for launched application process when using invokers -o param @@ -521,6 +583,10 @@ class InvokerTests(unittest.TestCase): kill_process(PREFERED_APP) + if(sighup): + self.sighup_applauncherd() + self.test_oom_adj_minus_two(False) + def test_invoker_applauncherd_dies(self): """ diff --git a/tests/harmattan/testscripts/test-single-instance.py b/tests/harmattan/testscripts/test-single-instance.py index a061f74..4c2dc96 100644 --- a/tests/harmattan/testscripts/test-single-instance.py +++ b/tests/harmattan/testscripts/test-single-instance.py @@ -78,6 +78,11 @@ class SingleInstanceTests(unittest.TestCase): if self.START_DAEMONS_AT_TEARDOWN: start_daemons() + def sighup_applauncherd(self): + same_pid, booster_status = send_sighup_to_applauncherd() + self.assert_(same_pid, "Applauncherd has new pid after SIGHUP") + self.assert_(booster_status, "Atleast one of the boosters is not restarted") + #Testcases def minimize(self, app = None, pid = None): # get window id @@ -358,55 +363,73 @@ class SingleInstanceTests(unittest.TestCase): def test_single_instance_abnormal_lock_release_without_invoker(self): self.single_instance_abnormal_lock_release('single-instance') - def test_single_instance_window_raise_with_invoker(self): + def test_single_instance_window_raise_with_invoker(self, sighup = True): self.single_instance_window_raise('invoker --type=m --single-instance') + if(sighup): + self.sighup_applauncherd() + self.test_single_instance_window_raise_with_invoker(False) - def test_single_instance_and_non_single_instance_with_invoker(self): + def test_single_instance_and_non_single_instance_with_invoker(self, sighup = True): self.single_instance_and_non_single_instance('invoker --type=m --single-instance') + if(sighup): + self.sighup_applauncherd() + self.test_single_instance_and_non_single_instance_with_invoker(False) - def test_single_instance_stress_test_with_invoker(self): + def test_single_instance_stress_test_with_invoker(self, sighup = True): self.single_instance_stress_test('invoker --type=m --single-instance') + if(sighup): + self.sighup_applauncherd() + self.test_single_instance_stress_test_with_invoker(False) - def test_single_instance_abnormal_lock_release_with_invoker(self): + def test_single_instance_abnormal_lock_release_with_invoker(self, sighup = True): self.single_instance_abnormal_lock_release('invoker --type=m --single-instance') + if(sighup): + self.sighup_applauncherd() + self.test_single_instance_abnormal_lock_release_with_invoker(False) - def test_single_instance_window_raise_with_script(self): + def test_single_instance_window_raise_with_script(self, sighup = True): self.single_instance_window_raise_with_script('invoker --single-instance --type=e') + if(sighup): + self.sighup_applauncherd() + self.test_single_instance_window_raise_with_script(False) - def test_single_instance_windowless_w_invoker(self): + def test_single_instance_windowless_w_invoker(self, sighup = True): """ To test that starting twice windowless application with invoker with single-instance - will report error in syslog + will report error in syslog """ - app = '/usr/bin/fala_windowless' - #remove already running fala_windowless if any + app = '/usr/bin/fala_windowless' + #remove already running fala_windowless if any kill_process(app) - #check applauncherd is started + #check applauncherd is started pid_ad = wait_for_single_applauncherd() self.assert_(pid_ad != None, "Applauncherd was not started") - #run fala_windowless first time + #run fala_windowless first time run_app_as_user_with_invoker(app, booster = 'm', arg = "--single-instance") pid1 = wait_for_app(app) self.assert_(pid1 != None, "%s was not started." % app) - #count previous error messages related to single instance application start attempts - st, op = commands.getstatusoutput('grep -c "]: Booster: Can\'t activate existing instance of the application!" /var/log/syslog ') - debug("The errors count in syslog is: %s" %op) - #run fala_windowless second time + #count previous error messages related to single instance application start attempts + st, op = commands.getstatusoutput('grep -c "]: Booster: Can\'t activate existing instance of the application!" /var/log/syslog ') + debug("The errors count in syslog is: %s" %op) + #run fala_windowless second time run_app_as_user_with_invoker(app, booster = 'm', arg = "--single-instance") - time.sleep(5) - pid2 = get_pid(app) + time.sleep(5) + pid2 = get_pid(app) #count error messages in sislog once again - st1, op1 = commands.getstatusoutput('grep -c "]: Booster: Can\'t activate existing instance of the application!" /var/log/syslog ') - debug("The errors count in syslog is: %s" %op1) - #cleanup - pid_list = pid2.split() + st1, op1 = commands.getstatusoutput('grep -c "]: Booster: Can\'t activate existing instance of the application!" /var/log/syslog ') + debug("The errors count in syslog is: %s" %op1) + #cleanup + pid_list = pid2.split() for pid in pid_list: kill_process(apppid=pid) - #check only one instance has been started + #check only one instance has been started self.assert_(len(pid_list) == 1, "Second instance of single-instance app has been started."); - #check +1 error message found - self.assert_(int(op) + 1 == int(op1), "No errror has been logged to syslog for windowless single instance app.") - + #check +1 error message found + self.assert_(int(op) + 1 == int(op1), "No errror has been logged to syslog for windowless single instance app.") + + if(sighup): + self.sighup_applauncherd() + self.test_single_instance_windowless_w_invoker(False) if __name__ == '__main__': # When run with testrunner, for some reason the PATH doesn't include diff --git a/tests/harmattan/testscripts/utils.py b/tests/harmattan/testscripts/utils.py index 14f6cea..3051785 100644 --- a/tests/harmattan/testscripts/utils.py +++ b/tests/harmattan/testscripts/utils.py @@ -134,6 +134,15 @@ def get_pid(appname): else: return None +def get_oldest_pid(appname): + temp = basename(appname)[:14] + st, op = commands.getstatusoutput("pgrep -o %s" % temp) + debug("The Pid of %s is %s" %(appname, op)) + if st == 0: + return op + else: + return None + def get_newest_pid(app): p = subprocess.Popen(['pgrep', '-n', app], shell = False, stdout = subprocess.PIPE, stderr = DEV_NULL) @@ -187,10 +196,11 @@ def wait_for_single_applauncherd(timeout = 20, sleep = 1): return pid def get_booster_pid(): - wait_for_app('booster-q') - wait_for_app('booster-e') - wait_for_app('booster-d') - wait_for_app('booster-m') + qpid = wait_for_app('booster-q') + epid = wait_for_app('booster-e') + dpid = wait_for_app('booster-d') + mpid = wait_for_app('booster-m') + return (epid, dpid, qpid, mpid) def kill_process(appname=None, apppid=None, signum=15): # obtained by running 'kill -l' @@ -339,3 +349,16 @@ def get_groups_for_user(): p.wait() return groups + +def send_sighup_to_applauncherd(): + pid1 = get_oldest_pid('applauncherd') + (e1, d1, q1, m1) = get_booster_pid() + debug("before sighup, applauncherd pid = ", pid1) + + kill_process(None, pid1, 1) + time.sleep(5) + pid2 = wait_for_single_applauncherd() + (e2, d2, q2, m2) = get_booster_pid() + debug("after sighup, applauncherd pid = ", pid2) + + return (pid1==pid2, m1!=m2 and q1!=q2 and d1!=d2 and e1!=e2)