testSuite.py

#!/usr/local/bin/python
#
#                               Copyright 2002
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#

__facility__ = "Online"
__abstract__ = "Example test suite"
__author__   = "S. Tuvi <stuvi@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2005/05/17 01:33:03 $").split(' ')[1]
__version__  = "$Revision: 1.5 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

# History:
#     $Log: testSuite.py,v $
#     Revision 1.5  2005/05/17 01:33:03  stuvi
#     As per LTE-264, added support for standalone suites and scripts.
#
#     Revision 1.4  2005/01/27 23:06:48  stuvi
#     Removed the lastScript parameter from the second scriptRun
#     We don't  have to check if the script was stopped in order to call doStopRun method.
#
#     Revision 1.3  2005/01/11 22:39:55  stuvi
#     no message
#
#     Revision 1.2  2004/10/20 03:44:55  stuvi
#     Commented out the selection of another schema since we want to use the one selected by RunControl.
#
#     Revision 1.1  2004/08/07 02:10:42  stuvi
#     Test suite examples.
#
#     Revision 1.5  2004/01/24 00:27:17  stuvi
#     Modified to use the appdir from preferences
#
#     Revision 1.4  2003/12/11 01:53:00  stuvi
#     Now calling the regular test applications to show that there is no need to change the tests to run them in suites.
#
#     Revision 1.3  2003/12/11 01:23:27  stuvi
#     Modified and documented the code according to the new rcSuite implementation.
#
#     Revision 1.2  2003/07/26 04:15:30  stuvi
#     Fixed schema path
#
#     Revision 1.1  2003/03/28 03:21:41  stuvi
#     Fixed FITS file status display
#     Added test suite capability
#

from   LATTE.runcontrol.rcSuite import rcSuite
import logging as     log
import                os


class userSuite(rcSuite):
  "Implmentation class for a user application"
  def __init__(self, gui, userId, debug):
    rcSuite.__init__(self, gui, userId, debug)
    log.debug("userSuite.__init__()")

  def getName(self):
    return __name__

  def setupSuite(self):
    # This method is executed after rcStartSuite successfully loads a schema (either
    # through the RunControl GUI or by reusing a previously loaded schema)
    #self.__schema = os.path.join(os.environ['ONLINE_ROOT'], 'LATTE/repos/simpleTemSchema.xml')
    pass

  def pauseSuite(self):
    # This method is executed before the currently running application is paused.
    # Note that there is currently no way to pause a suite, meaning if there is some
    # lengthy code that executes between scriptRun calls, that can not be paused.
    # Pause can be rejected by not returning None
    log.debug("userSuite.pauseSuite")
    return None

  def startSuite(self):
    try:

      # We pass the sesssion variables using a dictionary.
      # The set/getSessionVar methods can also be used.
      # Please do not use session variables which start with the "_" (underscore)
      # character as these are reserved for RunControl use
      sessionContext = {"test":"abc"}

      # The module name can either be a python file name or a module name
      # If a full path is specified then the module at that location is used
      # otherwise the PYTHONPATH is searched

      # The following script will change the value of session var "test"
      appDir = self.gui.preferences()['appdir']
      sessionStateAfterTest1 = self.scriptRun(module=os.path.join(appDir,'testAppCal'),
                                              context=sessionContext)

      # The following script will print the value of session var "test" and modify it
      sessionStateAfterTest2 = self.scriptRun(module=os.path.join(appDir,'testAppEvt'))

      print sessionStateAfterTest1
      print sessionStateAfterTest2

      # The schema for subsequent tests or suites can be changed using the following methods.
      # The schema chosen when the top level suite was selected in RunControl is still saved
      # in case the operator checked the "Reuse schema" checkbox on the load application dialog
      #self.readSchema(self.__schema)
      #self.applyConfig()

      # When the stop button is clicked a StopRequestedException is thrown after which
      # the current executing application is interrupted and rcStoprun and rcTeardown
      # is called. The suite calling the application should trap the exception using
      # a try block as demonstrated below and take the appropriate action.
      #
      # StopRequestedException class has three members. "msg" contains a generic message,
      # "suite" contains the name of the suite that was executing when the stop button was
      # clicked. Note that currently only the immediate parent suite name is recorded in
      # the exception. The third member is the "module" which contains the name of the
      # application that was executing at the time.
      self.scriptRun(module=os.path.join(appDir,'testSuite2'))
    except rcSuite.StopRequestedException, e:
      log.info("%s, suite: %s, module: %s" % (e.msg, e.suite, e.module))

    # Normally the suite appears to be running even after all the tests have been completed.
    # In order to stop the suite the operator must click on the stop button. Alternatively
    # the suite can issue the stop by calling self.gui.doStopRun similar to the way it is
    # done with applications. Note that a flag is being used to make sure that rcStopSuite
    # hasn't already been called (ie. the suite was interrupted before it completed).
    if self.gui is not None:
      self.gui.doStopRun()

  # stopSuite is called after rcStopSuite has been executed. If a sub-suite within the suite
  # is currently executing then the sub-suite's rcStopSuite is called and then this method
  # is called.
  def stopSuite(self):
    log.info("End of suite 1")

class userSuiteCallbacks(rcSuite.SuiteCallbacks):
  def __init__(self):
    pass

  def beforeSetupSuite(self, suite):
    log.info("Before setupSuite")

  def beforeStartSuite(self, suite):
    log.info("Before startSuite")

  def afterStopSuite(self, suite):
    log.info("After stopSuite")

# Standalone mode:
if __name__ == "__main__":

  mycb = userSuiteCallbacks()
  usl = rcSuite.StandaloneLauncher(logLevel="INFO")
  usl.launch(suiteClass=userSuite, user=321, callbacks=mycb)

---