Changes: Replace time.sleep in invoker test with loops waiting for some condition.

RevBy: Thyagarajan Balakrishnan <ext-thyagarajan.1.balakrishnan@nokia.com>

tests/harmattan/testscripts/test-invoker.py

@@ -31,7 +31,7 @@ from subprocess import Popen
 from utils import *
 from os.path import basename
 
-class InvokerTests(unittest.TestCase):
+class InvokerTests(CustomTestCase):
     def setUp(self):
         debug("setUp")
         if daemons_running():
@@ -75,34 +75,37 @@ class InvokerTests(unittest.TestCase):
             self.sighup_applauncherd()
             self.test_wait_term_e(False)
 
-    def _test_wait_term(self, app_path, app_name, btype):
+    def _test_wait_term(self, app_path, app_name, btype, directlyKillInvoker=True):
         """
         When calling invoker with --wait-term and killing invoker,
         the launched application should die too.
         """
 
+        kill_process(app_name)
         # Launch the app with invoker using --wait-term
         p = run_app_as_user_with_invoker(app_path,booster = btype, arg = '--wait-term' )
 
-        time.sleep(4)
-
         # Retrieve their pids
-        invoker_pid = wait_for_app('invoker')
         app_pid = wait_for_app(app_name)
 
         # Make sure that both apps started
-        self.assert_(invoker_pid != None, "invoker not executed?")
         self.assert_(app_pid != None, "%s not launched by invoker?" % app_path)
 
         # Send SIGTERM to invoker, the launched app should die
+        if directlyKillInvoker :
             debug(" Send SIGTERM to invoker, the launched app should die")
-        kill_process(None, invoker_pid, 15)
+            kill_process('invoker', None, 15)
+            self.waitForAsertEqual(lambda: p.poll(), 143, "invoker was not killed.", timeout = 3)
+        else :
+            debug(" Send SIGTERM to shell which runs invoker, the launched app should die")
+            kill_process(None, p.pid, 15)
+            self.waitForAsertEqual(lambda: p.poll(), -15, "invoker was not killed.", timeout = 3)
 
-        time.sleep(4)
+        debug("Invoker return code: %s" %(p.poll()))
 
-        # This should be None
+        self.waitForAsertEqual(lambda: get_pid(app_name), None,
-        app_pid2 = get_pid(app_name)
+                               "Application '%s' was not killed!" % app_path,
-        self.assert_(app_pid2 == None, "%s was not killed" % app_path)
+                               timeout = 8)
 
     def test_launch_wo_applauncherd(self):
         """
@@ -144,39 +147,31 @@ class InvokerTests(unittest.TestCase):
         #Test for m-booster
         debug("Test for m-booster")
         st, op = commands.getstatusoutput("/usr/share/applauncherd-testscripts/signal-forward/fala_sf_m.py")
-        time.sleep(3)
         debug("The Invoker killed by : <%s>" %op.split ('\n')[-1])
 
         self.assert_(op.split('\n')[-1].startswith('Segmentation fault') == True, "The invoker(m-booster) was not killed by the same signal")
-        time.sleep(2)
 
         #Test for d-booster
         debug("Test for d-booster")
         st, op = commands.getstatusoutput("/usr/share/applauncherd-testscripts/signal-forward/fala_sf_d.py")
-        time.sleep(3)
         debug("The Invoker killed by : %s" % op.split('\n')[-1])
 
         self.assert_(op.split('\n')[-1].startswith('Terminated') == True, "The invoker(d-booster) was not killed by the same signal")
-        time.sleep(2)
 
         #Test for e-booster
         debug("Test for e-booster")
         st, op = commands.getstatusoutput("/usr/share/applauncherd-testscripts/signal-forward/fala_sf_e.py")
-        time.sleep(3)
         debug("The Invoker killed by : %s" % op.split('\n')[-1])
 
         self.assert_(op.split('\n')[-1].startswith('Terminated') == True, "The invoker(e-booster) was not killed by the same signal")
-        time.sleep(2)
 
         #This case is launching the application in user mode
         #Test for q-booster
         debug("Test for q-booster")
         st, op = commands.getstatusoutput("/usr/share/applauncherd-testscripts/signal-forward/fala_sf_qt.py")
-        time.sleep(3)
         debug("The Invoker killed by : %s" %op.split('\n')[-1])
 
         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()
@@ -188,32 +183,39 @@ class InvokerTests(unittest.TestCase):
         Test the --delay parameter of the invoker.
         """
 
+        invokerDelay = 10
         # launch an app with invoker --delay n
         debug("launching fala_ft_hello ...")
-        p = Popen(['/usr/bin/invoker', '--delay', '10', '--type=m', '--no-wait',
+        p = Popen(['/usr/bin/invoker', '--delay', str(invokerDelay), '--type=m', '--no-wait',
                    '/usr/bin/fala_ft_hello'],
                   shell=False,
                   stdout=DEV_NULL, stderr=DEV_NULL)
 
-        # wait a little
+        pStartTime = time.time()
-        debug("waiting ...")
+        appPid = wait_for_app('fala_ft_hello', timeout=7)
-        time.sleep(5)
+        try:
+            falaStartTime = time.time()
 
-        success = True
+            # wait a little
+            debug("Waiting for invoker to terminate after %.1fs..." %(invokerDelay))
+            # time out loop, if invoker runs longer then invokerDelay + 1 this means that something is wrong
+            while time.time()<pStartTime + invokerDelay + 1 and p.poll()==None :
+                time.sleep(0.5)
 
+            endTime = time.time()
+            # check that invoker has terminated before timeout
             if p.poll()==None :
-            debug("NOT DEAD")
+                p.terminate()
-        else:
+                self.assert_(False, "invoker didn't terminate on time. "
-            debug("DEAD")
+                             "It was running for: %.1fs (%.1fs was expected)."
-            success = False
+                             %(endTime - pStartTime, invokerDelay))
-
+            debug("Invoker has terminated after %.1fs." %(endTime - pStartTime))
-        debug("waiting for invoker to terminate ...")
+            self.assert_(endTime - pStartTime > invokerDelay - 1,
-        p.wait()
+                         "invoker has terminated to soon: %.1fs (%.1fs was expected)" %(endTime - pStartTime, invokerDelay))
-
+            self.assertEqual(get_pid('fala_ft_hello'), appPid, "Test application shouldn't be killed.")
-        debug("terminating fala_ft_hello ...")
+        finally:
-        Popen(['pkill', 'fala_ft_hello']).wait()
+            kill_process('fala_ft_hello')
-
+        debug("Ok.")
-        self.assert_(success, "invoker terminated before delay elapsed")
 
         if(sighup):
             self.sighup_applauncherd()
@@ -257,23 +259,28 @@ class InvokerTests(unittest.TestCase):
 
         # invoker searches PATH for the executable
         p = run_app_as_user_with_invoker(PREFERED_APP, booster = 'm', arg = '--no-wait')
-        self.assert_(p.wait() == 0, "Couldn't launch fala_ft_hello")
+        try:
-        time.sleep(2)
+            self.waitForAsertEqual(lambda: p.poll(), 0, "Couldn't launch fala_ft_hello")
+        finally:
+            wait_for_app('fala_ft_hello')
             kill_process('fala_ft_hello')
 
         # launch with relative path
 
         p = run_cmd_as_user('cd /usr/share/; invoker --type=m --no-wait ' +
                             "../bin/fala_ft_hello")
-        self.assert_(p.wait() == 0, "Couldnt launch fala_ft_hello" + 
+        try:
-                    " with relative path")
+            self.waitForAsertEqual(lambda: p.poll(), 0, "Couldn't launch fala_ft_hello" +
-        time.sleep(2)
+                        " with relative path or invoker didn't terminate")
+        finally:
+            wait_for_app('fala_ft_hello')
             kill_process('fala_ft_hello')
 
         # and finally, try to launch something that doesn't exist
         p = run_cmd_as_user('invoker --type=m --no-wait spam_cake')
-        self.assert_(p.wait() != 127, "Found spam_cakefor some reason")
+        try :
-        time.sleep(2)
+            self.waitForAsertEqual(lambda: p.poll(), 1, "spam_cake has been found!")
+        finally:
             kill_process('spam_cake')
 
         if(sighup):
@@ -354,19 +361,17 @@ class InvokerTests(unittest.TestCase):
 
     def test_invoker_param_respawn_delay(self, sighup = True):
         p = run_cmd_as_user('invoker --respawn 10 --type=q --no-wait fala_ft_hello')
-
+        try :
-        time.sleep(7)
+            startTime = time.time()
-
+            wait_for_app('fala_ft_hello')
-        pid = get_pid('booster-q')
+            pid = wait_for_app('booster-q', timeout = startTime - time.time() + 12)
-        self.assert_(pid == None, "'booster-q' was respawned too soon")
+            endTime = time.time()
-
+            self.assert_(endTime-startTime>8, "'booster-q' was respawned too soon: %.1fs" %(endTime-startTime))
-        time.sleep(7)
+            self.assert_(pid != None, "'booster-q' was not respawned on time.")
-
-        pid = get_pid('booster-q')
-        self.assert_(pid != None, "'booster-q' was not respawned in time")
 
             p = run_cmd_as_user('invoker --respawn 256 --type=q --no-wait fala_ft_hello')
             self.assert_(p.wait() != 0, "invoker didn't die with too big respawn delay")
+        finally:
             kill_process('fala_ft_hello')
 
         if(sighup):
@@ -386,11 +391,9 @@ class InvokerTests(unittest.TestCase):
         invoker to the invoked process
         """
         st, op = commands.getstatusoutput("/usr/share/applauncherd-testscripts/signal-forward/fala_inv_sf.py")
-        time.sleep(3)
         debug("The Invoker killed by : <%s>" %op)
 
         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()
@@ -460,8 +463,7 @@ class InvokerTests(unittest.TestCase):
         os.system("ln -s /usr/bin/fala_wl /usr/bin/fala_link")
         cmd = "/usr/bin/invoker --type=m /usr/bin/fala_link"
         os.system('su - user -c "%s"&' %cmd)
-        time.sleep(3)
+        pid = wait_for_app("fala_link")
-        pid = get_pid("fala_link")
         os.system("rm /usr/bin/fala_link")
         kill_process("fala_link")
         self.assert_(pid != None ,"The application was not launched")
@@ -477,16 +479,18 @@ class InvokerTests(unittest.TestCase):
         -D = INVOKER_MSG_MAGIC_OPTION_DLOPEN_DEEP
         """
         p = run_app_as_user_with_invoker("/usr/bin/fala_wl", booster='m', arg = '-G')
-        time.sleep(3)
+        wait_for_app('fala_wl')
-        pid = p.pid
+        returnCode = p.poll()
         kill_process("fala_wl")
-        self.assert_(pid != None ,"The application was not launched")
+        p.wait()
+        self.assert_(returnCode == None ,"The application was not launched")
 
         p = run_app_as_user_with_invoker("/usr/bin/fala_wl", booster='m', arg = '-D')
-        time.sleep(3)
+        wait_for_app('fala_wl')
-        pid = p.pid
+        returnCode = p.poll()
         kill_process("fala_wl")
-        self.assert_(pid != None ,"The application was not launched")
+        p.wait()
+        self.assert_(returnCode == None ,"The application was not launched")
 
         if(sighup):
             self.sighup_applauncherd()
@@ -499,7 +503,6 @@ class InvokerTests(unittest.TestCase):
         #Test for a directory
         os.system("mkdir /usr/bin/fala_dir")
         st, op = commands.getstatusoutput("/usr/bin/invoker --type=m /usr/bin/fala_dir")
-        time.sleep(3)
         os.system("rm -rf /usr/bin/fala_dir")
         self.assert_(st != 0 ,"The application was not launched")
 
@@ -522,6 +525,8 @@ class InvokerTests(unittest.TestCase):
         Check that application is started and invoker is waiting termination before exit
         """
 
+        kill_process('fala_wait')
+
         # launch an app with invoker --wait-term
         debug("launching fala_wait ...")
         p = Popen(['/usr/bin/invoker', '--type=m', '--wait-term',
@@ -531,22 +536,25 @@ class InvokerTests(unittest.TestCase):
 
         # wait a little
         debug("waiting ...")
-        time.sleep(5)
+        wait_for_app('fala_wait', sleep = 0.3)
 
+        # fala_wait is quits after 6 seconds
+        endTime = time.time() + 6
         success = True
-
+        while time.time()<endTime-1 :
-        if p.poll() == None:
+            if p.poll() != None:
-            debug("NOT DEAD")
+                debug("invoker has end working before it was expected")
-        else:
-            debug("DEAD")
                 success = False
+                break
+            time.sleep(0.5)
 
+        if success :
             debug("waiting for invoker to terminate ...")
-        p.wait()
+        self.waitForAsert(lambda : p.poll() != None,
-
+                          "invoker didn't terminate")
-        debug("terminating fala_wait ...")
+        debug("...invoker has been terminated.")
-
+        self.assertEqual(get_pid('fala_wait'), None, "invoker died before fala_wait application.")
-        self.assert_(success, "invoker terminated before delay elapsed")
+        self.assert_(success, "invoker has ended execution before expected time")
 
         if(sighup):
             self.sighup_applauncherd()
@@ -573,15 +581,11 @@ class InvokerTests(unittest.TestCase):
 
         p = run_app_as_user_with_invoker(PREFERED_APP, booster = 'm',
                                          arg = '-o')
-        time.sleep(4)
+        pid = wait_for_app(PREFERED_APP)
-
-        pid = get_pid(PREFERED_APP)
-
         st, op = commands.getstatusoutput('cat /proc/%s/oom_adj' % pid)
-
-        self.assert_(op == '-2', "oom.adj of the launched process is not -1")
-
         kill_process(PREFERED_APP)
+        self.assert_(op == '-2', "oom.adj of the launched process is not -2."
+                     "cat return code: %s, oom_adj contains: '%s'" %(st, op))
 
         if(sighup):
             self.sighup_applauncherd()
@@ -604,12 +608,11 @@ class InvokerTests(unittest.TestCase):
         self.assert_(pid != None, "The application was not launched")
 
         stop_applauncherd()
-        time.sleep(20) #wait app to be terminated and invoker to exit
 
-        pid = wait_for_app(PREFERED_APP, timeout = 2) #don't need to wait long since the app supposed not running
+        self.assert_(wait_for_process_end('applauncherd'), "applauncherd was not stoped.")
-        if pid != None:
+        self.waitForAsert(lambda:p.poll() != None, "Invoker didn't terminate.")
-            kill_process(PREFERED_APP)
+        self.assert_(wait_for_process_end(PREFERED_APP), "invoker didn't kill application after applauncherd termination.")
-        self.assert_(pid == None, "The application is still running!")
+
 
 # main
 if __name__ == '__main__':

tests/harmattan/testscripts/utils.py

@@ -5,6 +5,7 @@ import time
 import sys
 import re
 import unittest
+import types
 from subprocess import Popen
 from os.path import basename
 
@@ -26,28 +27,29 @@ class CustomTestCase(unittest.TestCase) :
                type(periodicCheck) == types.LambdaType)
         start = time.time()
         stop = start + timeout
-        newValue = None
+
-        debug("Waiting for '%s' to return True value in time of %.1fs." %(periodicCheck.__doc__, timeout))
+        debug("Waiting for '%s' to return True value in time of %.1fs." %(periodicCheck.__name__, timeout))
         while stop > time.time() :
             if periodicCheck() :
-                debug("'%s' has returned True after %.1fs." %(periodicCheck.__doc__, time.time()-start))
+                debug("'%s' has returned True after %.1fs." %(periodicCheck.__name__, time.time()-start))
                 return
             time.sleep(sleep)
         debug("waitForAsert has timed out after %ss." %timeout)
         self.assert_(periodicCheck(), msg)
         return
 
-    def waitForAsertEqual(self, periodickCheck, expectedValue, msg="", timeout=20, sleep=1) :
+    def waitForAsertEqual(self, periodicCheck, expectedValue, msg="", timeout=20, sleep=1) :
         assert(type(periodicCheck) == types.FunctionType or
                type(periodicCheck) == types.LambdaType)
         start = time.time()
         stop = start + timeout
-        debug("Waiting for '%s' to return True value in time of %.1fs." %(periodicCheck.__doc__, timeout))
+        debug("Waiting for '%s' to return expected value: '%s' in time of %.1fs."
+              %(periodicCheck.__name__, expectedValue, timeout))
 
         while stop > time.time() :
             if periodicCheck() == expectedValue :
                 debug("'%s' has returned expected value: '%s' after %.1fs."
-                      %(periodicCheck.__doc__, expectedValue, time.time()-start))
+                      %(periodicCheck.__name__, expectedValue, time.time()-start))
                 return
             time.sleep(sleep)
         debug("waitForAsertEqual has timed out after %ss." %timeout)
@@ -250,7 +252,7 @@ def wait_for_app(app = None, timeout = 40, sleep = 1):
     pid = None
     start = time.time()
 
-    debug("Waiting for '%s' to startup in %ss time" %(app, timeout))
+    debug("Waiting for '%s' to startup in %.1fs time" %(app, timeout))
     while pid == None and time.time() < start + timeout:
         p = subprocess.Popen(['pgrep', '-n', app], shell = False,
                          stdout = subprocess.PIPE, stderr = DEV_NULL)