From abae5261802df66871d492e95297d6298a93b649 Mon Sep 17 00:00:00 2001
From: Serge Rehbinder <serge.rehbinder@cea.fr>
Date: Mon, 25 Jul 2016 11:41:45 +0200
Subject: [PATCH] Remove the --grid option from the test command and replace it
 by the --base option

---
 commands/test.py          | 139 ++++++++++++---------------
 src/fork.py               |  15 ++-
 src/test_module.py        | 194 +++++++++++++++++---------------------
 src/xsl/command.xsl       |  71 +++++++++-----
 src/xsl/test.xsl          |  18 ++--
 test/run_all.sh           |   1 +
 test/test/test_command.py | 102 ++++++++++++++++++++
 7 files changed, 314 insertions(+), 226 deletions(-)
 create mode 100644 test/test/test_command.py

diff --git a/commands/test.py b/commands/test.py
index 571f67c..1bed1a3 100644
--- a/commands/test.py
+++ b/commands/test.py
@@ -34,25 +34,20 @@ from src.xmlManager import add_simple_node
 
 # Define all possible option for the test command :  sat test <options>
 parser = src.options.Options()
-parser.add_option('a', 'appli', 'string', 'appli',
-    _('Use this option to specify the path to an installed application.'))
-parser.add_option('g', 'grid', 'string', 'grid',
-    _("Indicate the name of the grid to test.\n\tThis name has to be registered"
-      " in sat. If your test base is not known by sat, use the option --dir."))
+parser.add_option('b', 'base', 'string', 'base',
+    _("Indicate the name of the test base to use.\n\tThis name has to be "
+      "registered in your application and in a project.\n\tA path to a test "
+      "base can also be used."))
+parser.add_option('l', 'launcher', 'string', 'launcher',
+    _("Use this option to specify the path to a SALOME launcher to use to "
+      "launch the test scripts of the test base."))
 parser.add_option('m', 'module', 'list', 'modules',
-    _('Indicate which module(s) to test (subdirectory of the grid).'))
+    _('Indicate which module(s) to test (subdirectory of the test base).'))
 parser.add_option('t', 'type', 'list', 'types',
     _('Indicate which type(s) to test (subdirectory of the module).'))
-parser.add_option('d', 'dir', 'string', 'dir',
-    _('Indicate the directory containing the test base.'), "")
-parser.add_option('', 'mode', 'string', 'mode',
-    _("Indicate which kind of test to run. If MODE is 'batch' only python and"
-      " NO_GUI tests are run."), "normal")
 parser.add_option('', 'display', 'string', 'display',
     _("Set the display where to launch SALOME."
 "\tIf value is NO then option --show-desktop=0 will be used to launch SALOME."))
-parser.add_option('', 'light', 'boolean', 'light',
-    _('Only run minimal tests declared in TestsLight.txt.'), False)
 
 def description():
     '''method that is called when salomeTools is called with --help option.
@@ -72,17 +67,17 @@ def parse_option(args, config):
     """
     (options, args) = parser.parse_args(args)
 
-    if not options.appli:
-        options.appli = ""
-    elif not os.path.isabs(options.appli):
+    if not options.launcher:
+        options.launcher = ""
+    elif not os.path.isabs(options.launcher):
         if not src.config_has_application(config):
             raise src.SatException(_("An application is required to use a "
                                      "relative path with option --appli"))
-        options.appli = os.path.join(config.APPLICATION.workdir, options.appli)
+        options.launcher = os.path.join(config.APPLICATION.workdir, options.launcher)
 
-        if not os.path.exists(options.appli):
-            raise src.SatException(_("Application not found: %s") % 
-                                   options.appli)
+        if not os.path.exists(options.launcher):
+            raise src.SatException(_("Launcher not found: %s") % 
+                                   options.launcher)
 
     return (options, args)
 
@@ -153,26 +148,26 @@ def move_test_results(in_dir, what, out_dir, logger):
         shutil.copy2(os.path.join(in_dir, what, 'env_info.py'),
                      os.path.join(finalPath, what, 'env_info.py'))
 
-        # for all sub directory (ie grid) in the BASES directory
-        for grid in os.listdir(os.path.join(in_dir, what, 'BASES')):
-            outgrid = os.path.join(finalPath, what, 'BASES', grid)
-            ingrid = os.path.join(in_dir, what, 'BASES', grid)
+        # for all sub directory (ie testbase) in the BASES directory
+        for testbase in os.listdir(os.path.join(in_dir, what, 'BASES')):
+            outtestbase = os.path.join(finalPath, what, 'BASES', testbase)
+            intestbase = os.path.join(in_dir, what, 'BASES', testbase)
 
             # ignore files in root dir
-            if not os.path.isdir(ingrid):
+            if not os.path.isdir(intestbase):
                 continue
 
-            os.makedirs(outgrid)
-            #logger.write("  copy grid %s\n" % grid, 5)
+            os.makedirs(outtestbase)
+            #logger.write("  copy testbase %s\n" % testbase, 5)
 
-            for module_ in [m for m in os.listdir(ingrid) if os.path.isdir(
-                                                    os.path.join(ingrid, m))]:
+            for module_ in [m for m in os.listdir(intestbase) if os.path.isdir(
+                                                    os.path.join(intestbase, m))]:
                 # ignore source configuration directories
                 if module_[:4] == '.git' or module_ == 'CVS':
                     continue
 
-                outmodule = os.path.join(outgrid, module_)
-                inmodule = os.path.join(ingrid, module_)
+                outmodule = os.path.join(outtestbase, module_)
+                inmodule = os.path.join(intestbase, module_)
                 os.makedirs(outmodule)
                 #logger.write("    copy module %s\n" % module_, 5)
 
@@ -222,7 +217,8 @@ def check_remote_machine(machine_name, logger):
     if p.returncode != 0:
         logger.write(src.printcolors.printc(src.KO_STATUS) + "\n", 1)
         logger.write("    " + src.printcolors.printcError(p.stderr.read()), 2)
-        raise src.SatException("No ssh access to the display machine.")
+        logger.write(src.printcolors.printcWarning((
+                                    "No ssh access to the display machine.")),1)
     else:
         logger.write(src.printcolors.printcSuccess(src.OK_STATUS) + "\n\n", 4)
 
@@ -264,18 +260,18 @@ def create_test_report(config, dest_path, stylesheet, xmlname=""):
         amend = add_simple_node(prod_node, "amend")
         tt = {}
         for test in config.TESTS:
-            if not tt.has_key(test.grid):
-                tt[test.grid] = [test]
+            if not tt.has_key(test.testbase):
+                tt[test.testbase] = [test]
             else:
-                tt[test.grid].append(test)
+                tt[test.testbase].append(test)
 
-        for grid in tt.keys():
-            gn = add_simple_node(tests, "grid")
-            gn.attrib['name'] = grid
+        for testbase in tt.keys():
+            gn = add_simple_node(tests, "testbase")
+            gn.attrib['name'] = testbase
             nb, nb_pass, nb_failed, nb_timeout, nb_not_run = 0, 0, 0, 0, 0
             modules = {}
             types = {}
-            for test in tt[grid]:
+            for test in tt[testbase]:
                 #print test.module
                 if not modules.has_key(test.module):
                     mn = add_simple_node(gn, "module")
@@ -391,21 +387,15 @@ def run(args, runner, logger):
     '''
     (options, args) = parse_option(args, runner.cfg)
 
-    if options.grid and options.dir:
-        raise src.SatException(_("The options --grid and --dir are not "
-                                 "compatible!"))
-
     with_application = False
     if runner.cfg.VARS.application != 'None':
         logger.write(_('Running tests on application %s\n') % 
                             src.printcolors.printcLabel(
                                                 runner.cfg.VARS.application), 1)
         with_application = True
-    elif options.dir:
-        logger.write(_('Running tests from directory %s\n') % 
-                            src.printcolors.printcLabel(options.dir), 1)
-    elif not options.grid:
-        raise src.SatException(_('a grid or a directory is required'))
+    elif not options.base:
+        raise src.SatException(_('A test base is required. Use the --base '
+                                 'option'))
 
     if with_application:
         # check if environment is loaded
@@ -414,16 +404,15 @@ def run(args, runner, logger):
                             "SALOME environment already sourced")) + "\n", 1)
             
         
-    elif options.appli:
+    elif options.launcher:
         logger.write(src.printcolors.printcWarning(_("Running SALOME "
                                                 "application.")) + "\n\n", 1)
     else:
-        logger.write(src.printcolors.printcWarning(_("WARNING running "
-                                            "without a product.")) + "\n\n", 1)
-
-        # check if environment is loaded
-        if not 'KERNEL_ROOT_DIR' in os.environ:
-            raise src.SatException(_("SALOME environment not found") + "\n")
+        msg = _("Impossible to find any launcher.\nPlease specify an "
+                "application or a launcher")
+        logger.write(src.printcolors.printcError(msg))
+        logger.write("\n")
+        return 1
 
     # set the display
     show_desktop = (options.display and options.display.upper() == "NO")
@@ -476,19 +465,19 @@ def run(args, runner, logger):
 
     # create hash from session information
     dirname = sha1(content.encode()).hexdigest()
-    session_dir = os.path.join(tmp_dir, dirname)
-    os.makedirs(session_dir)
-    os.environ['TT_TMP_RESULT'] = session_dir
+    base_dir = os.path.join(tmp_dir, dirname)
+    os.makedirs(base_dir)
+    os.environ['TT_TMP_RESULT'] = base_dir
 
     # create env_info file
-    f = open(os.path.join(session_dir, 'env_info.py'), "w")
+    f = open(os.path.join(base_dir, 'env_info.py'), "w")
     f.write(content)
     f.close()
 
     # create working dir and bases dir
-    working_dir = os.path.join(session_dir, 'WORK')
+    working_dir = os.path.join(base_dir, 'WORK')
     os.makedirs(working_dir)
-    os.makedirs(os.path.join(session_dir, 'BASES'))
+    os.makedirs(os.path.join(base_dir, 'BASES'))
     os.chdir(working_dir)
 
     if 'PYTHONPATH' not in os.environ:
@@ -500,34 +489,26 @@ def run(args, runner, logger):
 
     # launch of the tests
     #####################
-    grid = ""
-    if options.grid:
-        grid = options.grid
-    elif (not options.dir and with_application and 
-                                        "test_base" in runner.cfg.APPLICATION):
-        grid = runner.cfg.APPLICATION.test_base.name
+    test_base = ""
+    if options.base:
+        test_base = options.base
+    elif with_application and "test_base" in runner.cfg.APPLICATION:
+        test_base = runner.cfg.APPLICATION.test_base.name
 
     src.printcolors.print_value(logger, _('Display'), os.environ['DISPLAY'], 2)
     src.printcolors.print_value(logger, _('Timeout'),
                                 runner.cfg.SITE.test.timeout, 2)
-    if 'timeout_app' in runner.cfg.SITE.test:
-        src.printcolors.print_value(logger, _('Timeout Salome'),
-                                    runner.cfg.SITE.test.timeout_app, 2)
-    src.printcolors.print_value(logger, _('Light mode'), options.light, 2)
-    src.printcolors.print_value(logger, _("Working dir"), session_dir, 3)
+    src.printcolors.print_value(logger, _("Working dir"), base_dir, 3)
 
     # create the test object
     test_runner = src.test_module.Test(runner.cfg,
                                   logger,
-                                  session_dir,
-                                  grid=grid,
+                                  base_dir,
+                                  testbase=test_base,
                                   modules=options.modules,
                                   types=options.types,
-                                  appli=options.appli,
-                                  mode=options.mode,
-                                  dir_=options.dir,
-                                  show_desktop=show_desktop,
-                                  light=options.light)
+                                  launcher=options.launcher,
+                                  show_desktop=show_desktop)
     
     # run the test
     logger.allowPrintLevel = False
diff --git a/src/fork.py b/src/fork.py
index 0a3ef59..5a6582a 100644
--- a/src/fork.py
+++ b/src/fork.py
@@ -22,14 +22,25 @@ import time
 import pickle
 import subprocess
 
-# Display progress
-# ----------------
 def show_progress(logger, top, delai, ss=""):
+    """shortcut function to display the progression
+    
+    :param logger Logger: The logging instance
+    :param top int: the number to display
+    :param delai int: the number max
+    :param ss str: the string to display
+    """
     logger.write("\r%s\r%s %s / %s " % ((" " * 30), ss, top, (delai - top)), 4,
                  False)
     logger.flush()
 
 def write_back(logger, message, level):
+    """shortcut function to write at the begin of the line
+    
+    :param logger Logger: The logging instance
+    :param message str: the text to display
+    :param level int: the level of verbosity
+    """
     logger.write("\r%s\r%s" % ((" " * 40), message), level)
 
 # Launch command
diff --git a/src/test_module.py b/src/test_module.py
index e8dfb86..0b934bf 100644
--- a/src/test_module.py
+++ b/src/test_module.py
@@ -26,7 +26,12 @@ except:
             exec(code, global_vars, local_vars)
 
 
-import os, sys, datetime, shutil, string
+import os
+import sys
+import datetime
+import shutil
+import string
+import imp
 import subprocess
 from . import fork
 import src
@@ -51,31 +56,20 @@ class Test:
                  config,
                  logger,
                  sessionDir,
-                 grid="",
+                 testbase="",
                  modules=None,
                  types=None,
-                 appli="",
-                 mode="normal",
-                 dir_="",
-                 show_desktop=True,
-                 light=False):
+                 launcher="",
+                 show_desktop=True):
         self.modules = modules
         self.config = config
         self.logger = logger
         self.sessionDir = sessionDir
-        self.dir = dir_
         self.types = types
-        self.appli = appli
-        self.mode = mode
+        self.launcher = launcher
         self.show_desktop = show_desktop
-        self.light = light
 
-        if len(self.dir) > 0:
-            self.logger.write("\n", 3, False)
-            self.prepare_grid_from_dir("DIR", self.dir)
-            self.currentGrid = "DIR"
-        else:
-            self.prepare_grid(grid)
+        self.prepare_testbase(testbase)
 
         self.settings = {}
         self.known_errors = None
@@ -98,22 +92,22 @@ class Test:
             shutil.copytree(source, target,
                             symlinks=True)
 
-    def prepare_grid_from_dir(self, grid_name, grid_dir):
-        self.logger.write(_("get grid from dir: %s\n") % \
-                          src.printcolors.printcLabel(grid_dir), 3)
-        if not os.access(grid_dir, os.X_OK):
+    def prepare_testbase_from_dir(self, testbase_name, testbase_dir):
+        self.logger.write(_("get test base from dir: %s\n") % \
+                          src.printcolors.printcLabel(testbase_dir), 3)
+        if not os.access(testbase_dir, os.X_OK):
             raise src.SatException(_("testbase %(name)s (%(dir)s) does not "
-                                     "exist ...\n") % { 'name': grid_name,
-                                                       'dir': grid_dir })
+                                     "exist ...\n") % { 'name': testbase_name,
+                                                       'dir': testbase_dir })
 
-        self._copy_dir(grid_dir,
-                       os.path.join(self.sessionDir, 'BASES', grid_name))
+        self._copy_dir(testbase_dir,
+                       os.path.join(self.sessionDir, 'BASES', testbase_name))
 
-    def prepare_grid_from_git(self, grid_name, grid_base, grid_tag):
+    def prepare_testbase_from_git(self, testbase_name, testbase_base, testbase_tag):
         self.logger.write(
-            _("get grid '%(grid)s' with '%(tag)s' tag from git\n") % {
-                               "grid" : src.printcolors.printcLabel(grid_name),
-                               "tag" : src.printcolors.printcLabel(grid_tag)},
+            _("get test base '%(testbase)s' with '%(tag)s' tag from git\n") % {
+                               "testbase" : src.printcolors.printcLabel(testbase_name),
+                               "tag" : src.printcolors.printcLabel(testbase_tag)},
                           3)
         try:
             def set_signal(): # pragma: no cover
@@ -123,14 +117,14 @@ class Test:
 
             cmd = "git clone --depth 1 %(base)s %(dir)s"
             cmd += " && cd %(dir)s"
-            if grid_tag=='master':
+            if testbase_tag=='master':
                 cmd += " && git fetch origin %(branch)s"
             else:
                 cmd += " && git fetch origin %(branch)s:%(branch)s"
             cmd += " && git checkout %(branch)s"
-            cmd = cmd % { 'branch': grid_tag,
-                         'base': grid_base,
-                         'dir': grid_name }
+            cmd = cmd % { 'branch': testbase_tag,
+                         'base': testbase_base,
+                         'dir': testbase_name }
 
             self.logger.write("> %s\n" % cmd, 5)
             if src.architecture.is_windows():
@@ -150,15 +144,15 @@ class Test:
             if res != 0:
                 raise src.SatException(_("Error: unable to get test base "
                                          "'%(name)s' from git '%(repo)s'.") % \
-                                       { 'name': grid_name, 'repo': grid_base })
+                                       { 'name': testbase_name, 'repo': testbase_base })
 
         except OSError:
             self.logger.error(_("git is not installed. exiting...\n"))
             sys.exit(0)
 
-    def prepare_grid_from_svn(self, user, grid_name, grid_base):
-        self.logger.write(_("get grid '%s' from svn\n") % \
-                          src.printcolors.printcLabel(grid_name), 3)
+    def prepare_testbase_from_svn(self, user, testbase_name, testbase_base):
+        self.logger.write(_("get test base '%s' from svn\n") % \
+                          src.printcolors.printcLabel(testbase_name), 3)
         try:
             def set_signal(): # pragma: no cover
                 """see http://bugs.python.org/issue1652"""
@@ -166,7 +160,7 @@ class Test:
                 signal.signal(signal.SIGPIPE, signal.SIG_DFL)
 
             cmd = "svn checkout --username %(user)s %(base)s %(dir)s"
-            cmd = cmd % { 'user': user, 'base': grid_base, 'dir': grid_name }
+            cmd = cmd % { 'user': user, 'base': testbase_base, 'dir': testbase_name }
 
             self.logger.write("> %s\n" % cmd, 5)
             if src.architecture.is_windows():
@@ -187,7 +181,7 @@ class Test:
             if res != 0:
                 raise src.SatException(_("Error: unable to get test base '%(nam"
                                          "e)s' from svn '%(repo)s'.") % \
-                                       { 'name': grid_name, 'repo': grid_base })
+                                       { 'name': testbase_name, 'repo': testbase_base })
 
         except OSError:
             self.logger.error(_("svn is not installed. exiting...\n"))
@@ -195,45 +189,51 @@ class Test:
 
     ##
     # Configure tests base.
-    def prepare_grid(self, grid_name):
+    def prepare_testbase(self, test_base_name):
         src.printcolors.print_value(self.logger,
-                                    _("Testing grid"),
-                                    grid_name,
+                                    _("Test base"),
+                                    test_base_name,
                                     3)
         self.logger.write("\n", 3, False)
 
-        # search for the grid
+        # search for the test base
         test_base_info = None
         for project_name in self.config.PROJECTS.projects:
             project_info = self.config.PROJECTS.projects[project_name]
             for t_b_info in project_info.test_bases:
-                if t_b_info.name == grid_name:
+                if t_b_info.name == test_base_name:
                     test_base_info = t_b_info
         
         if not test_base_info:
-            message = _("########## WARNING: grid '%s' not found\n") % grid_name
+            if os.path.exists(test_base_name):
+                self.prepare_testbase_from_dir("DIR", test_base_name)
+                self.currentTestBase = "DIR"
+                return 0
+        
+        if not test_base_info:
+            message = _("########## WARNING: base '%s' not found\n") % test_base_name
             raise src.SatException(message)
 
         if test_base_info.get_sources == "dir":
-            self.prepare_grid_from_dir(grid_name, test_base_info.info.dir)
+            self.prepare_testbase_from_dir(test_base_name, test_base_info.info.dir)
         elif test_base_info.get_sources == "git":
-            self.prepare_grid_from_git(grid_name,
+            self.prepare_testbase_from_git(test_base_name,
                                        test_base_info.info.base,
                                        self.config.APPLICATION.test_base.tag)
         elif test_base_info.get_sources == "svn":
             svn_user = src.get_cfg_param(test_base_info.svn_info,
                                          "svn_user",
                                          self.config.USER.svn_user)
-            self.prepare_grid_from_svn(svn_user,
-                                       grid_name,
+            self.prepare_testbase_from_svn(svn_user,
+                                       test_base_name,
                                        test_base_info.info.base)
         else:
-            raise src.SatException(_("unknown source type '%(type)s' for testb"
-                                     "ase '%(grid)s' ...\n") % {
+            raise src.SatException(_("unknown source type '%(type)s' for test b"
+                                     "ase '%(base)s' ...\n") % {
                                         'type': test_base_info.get_sources,
-                                        'grid': grid_name })
+                                        'base': test_base_name })
 
-        self.currentGrid = grid_name
+        self.currentTestBase = test_base_name
 
     ##
     # Searches if the script is declared in known errors pyconf.
@@ -398,11 +398,11 @@ class Test:
                                                       "KERNEL").install_dir
 
         # Case where there the appli option is called (with path to launcher)
-        if len(self.appli) > 0:
+        if len(self.launcher) > 0:
             # There are two cases : The old application (runAppli) 
             # and the new one
-            launcherName = os.path.basename(self.appli)
-            launcherDir = os.path.dirname(self.appli)
+            launcherName = os.path.basename(self.launcher)
+            launcherDir = os.path.dirname(self.launcher)
             if launcherName == 'runAppli':
                 # Old application
                 cmd = "for i in " + launcherDir + "/env.d/*.sh; do source ${i};"
@@ -410,7 +410,7 @@ class Test:
             else:
                 # New application
                 cmd = "echo -e 'import os\nprint os.environ[\"KERNEL_ROOT_DIR\""
-                "]' > tmpscript.py; %s shell tmpscript.py" % self.appli
+                "]' > tmpscript.py; %s shell tmpscript.py" % self.launcher
             root_dir = subprocess.Popen(cmd,
                             stdout=subprocess.PIPE,
                             shell=True,
@@ -418,7 +418,7 @@ class Test:
         
         # import module salome_utils from KERNEL that gives 
         # the right getTmpDir function
-        import imp
+        
         (file_, pathname, description) = imp.find_module("salome_utils",
                                                          [os.path.join(root_dir,
                                                                     'bin',
@@ -465,14 +465,14 @@ class Test:
             return binSalome, binPython, killSalome
         
         # Case where there the appli option is called (with path to launcher)
-        if len(self.appli) > 0:
+        if len(self.launcher) > 0:
             # There are two cases : The old application (runAppli) 
             # and the new one
-            launcherName = os.path.basename(self.appli)
-            launcherDir = os.path.dirname(self.appli)
+            launcherName = os.path.basename(self.launcher)
+            launcherDir = os.path.dirname(self.launcher)
             if launcherName == 'runAppli':
                 # Old application
-                binSalome = self.appli
+                binSalome = self.launcher
                 binPython = ("for i in " +
                              launcherDir +
                              "/env.d/*.sh; do source ${i}; done ; python")
@@ -482,9 +482,9 @@ class Test:
                 return binSalome, binPython, killSalome
             else:
                 # New application
-                binSalome = self.appli
-                binPython = self.appli + ' context'
-                killSalome = self.appli + ' killall'
+                binSalome = self.launcher
+                binPython = self.launcher + ' shell'
+                killSalome = self.launcher + ' killall'
                 return binSalome, binPython, killSalome
 
         # SALOME version detection and APPLI repository detection
@@ -520,7 +520,7 @@ class Test:
             if src.architecture.is_windows():
                 binSalome += '.bat'
 
-            binPython = binSalome + ' context'
+            binPython = binSalome + ' shell'
             killSalome = binSalome + ' killall'
             return binSalome, binPython, killSalome
                 
@@ -557,10 +557,10 @@ class Test:
         logWay = os.path.join(self.sessionDir, "WORK", "log_cxx")
 
         status = False
-        ellapsed = -1
+        elapsed = -1
         if self.currentType.startswith("NOGUI_"):
             # runSalome -t (bash)
-            status, ellapsed = fork.batch(binSalome, self.logger,
+            status, elapsed = fork.batch(binSalome, self.logger,
                                         os.path.join(self.sessionDir, "WORK"),
                                         [ "-t",
                                          "--shutdown-server=1",
@@ -570,7 +570,7 @@ class Test:
 
         elif self.currentType.startswith("PY_"):
             # python script.py
-            status, ellapsed = fork.batch(binPython, self.logger,
+            status, elapsed = fork.batch(binPython, self.logger,
                                           os.path.join(self.sessionDir, "WORK"),
                                           [script_path],
                                           delai=time_out, log=logWay)
@@ -578,7 +578,7 @@ class Test:
         else:
             opt = "-z 0"
             if self.show_desktop: opt = "--show-desktop=0"
-            status, ellapsed = fork.batch_salome(binSalome,
+            status, elapsed = fork.batch_salome(binSalome,
                                                  self.logger,
                                                  os.path.join(self.sessionDir,
                                                               "WORK"),
@@ -591,17 +591,17 @@ class Test:
                                                  log=logWay,
                                                  delaiapp=time_out_salome)
 
-        self.logger.write("status = %s, ellapsed = %s\n" % (status, ellapsed),
+        self.logger.write("status = %s, elapsed = %s\n" % (status, elapsed),
                           5)
 
         # create the test result to add in the config object
         test_info = src.pyconf.Mapping(self.config)
-        test_info.grid = self.currentGrid
+        test_info.testbase = self.currentTestBase
         test_info.module = self.currentModule
         test_info.type = self.currentType
         test_info.script = src.pyconf.Sequence(self.config)
 
-        script_results = self.read_results(listTest, ellapsed == time_out)
+        script_results = self.read_results(listTest, elapsed == time_out)
         for sr in sorted(script_results.keys()):
             self.nb_run += 1
 
@@ -665,13 +665,8 @@ class Test:
 
     ##
     # Runs all tests of a type.
-    def run_type_tests(self, light_test):
-        if self.light:
-            if not any(map(lambda l: l.startswith(self.currentType),
-                           light_test)):
-                # no test to run => skip
-                return
-        
+    def run_type_tests(self):
+       
         self.logger.write(self.write_test_margin(2), 3)
         self.logger.write("Type = %s\n" % src.printcolors.printcLabel(
                                                     self.currentType), 3, False)
@@ -683,10 +678,6 @@ class Test:
         tests = filter(lambda l: l.endswith(".py"), tests)
         tests = sorted(tests, key=str.lower)
 
-        if self.light:
-            tests = filter(lambda l: os.path.join(self.currentType,
-                                                  l) in light_test, tests)
-
         # build list of known failures
         cat = "%s/%s/" % (self.currentModule, self.currentType)
         ignoreDict = {}
@@ -715,23 +706,6 @@ class Test:
             types = filter(lambda l: os.path.isdir(os.path.join(module_path,
                                                                 l)), types)
 
-        # in batch mode keep only modules with NOGUI or PY
-        if self.mode == "batch":
-            types = filter(lambda l: ("NOGUI" in l or "PY" in l), types)
-
-        light_test = []
-        if self.light:
-            light_path = os.path.join(module_path, C_TESTS_LIGHT_FILE)
-            if not os.path.exists(light_path):
-                types = []
-                msg = src.printcolors.printcWarning(_("List of light tests not"
-                                                    " found: %s") % light_path)
-                self.logger.write(msg + "\n")
-            else:
-                # read the file
-                light_file = open(light_path, "r")
-                light_test = map(lambda l: l.strip(), light_file.readlines())
-
         types = sorted(types, key=str.lower)
         for type_ in types:
             if not os.path.exists(os.path.join(module_path, type_)):
@@ -740,11 +714,11 @@ class Test:
                                             "found" % type_) + "\n", 3, False)
             else:
                 self.currentType = type_
-                self.run_type_tests(light_test)
+                self.run_type_tests()
 
     ##
-    # Runs test grid.
-    def run_grid_tests(self):
+    # Runs test testbase.
+    def run_testbase_tests(self):
         res_dir = os.path.join(self.currentDir, "RESSOURCES")
         os.environ['PYTHONPATH'] =  (res_dir + 
                                      os.pathsep + 
@@ -757,10 +731,10 @@ class Test:
         self.logger.write("\n", 4, False)
 
         self.logger.write(self.write_test_margin(0), 3)
-        grid_label = "Grid = %s\n" % src.printcolors.printcLabel(
-                                                            self.currentGrid)
-        self.logger.write(grid_label, 3, False)
-        self.logger.write("-" * len(src.printcolors.cleancolor(grid_label)), 3)
+        testbase_label = "Test base = %s\n" % src.printcolors.printcLabel(
+                                                            self.currentTestBase)
+        self.logger.write(testbase_label, 3, False)
+        self.logger.write("-" * len(src.printcolors.cleancolor(testbase_label)), 3)
         self.logger.write("\n", 3, False)
 
         # load settings
@@ -838,8 +812,8 @@ class Test:
         self.logger.write("\n", 2, False)
         self.currentDir = os.path.join(self.sessionDir,
                                        'BASES',
-                                       self.currentGrid)
-        self.run_grid_tests()
+                                       self.currentTestBase)
+        self.run_testbase_tests()
 
         # calculate total execution time
         totalTime = datetime.datetime.now() - initTime
diff --git a/src/xsl/command.xsl b/src/xsl/command.xsl
index b444b82..2969bec 100644
--- a/src/xsl/command.xsl
+++ b/src/xsl/command.xsl
@@ -4,30 +4,40 @@
 <xsl:template match="/">
 
 <head>  
-    <title>SAlomeTools log</title>
-    <style type="text/css">
-        table       { width : 100%;
-                      margin:1px;
-                      padding:1px;
-                      border-collapse:collapse;
-                      empty-cells : show;
-                    }
-        td          { vertical-align : center; padding: 15px; }
-        h1          { text-align : center; }
-        .legend     { font-weight : bold;
-                      text-align : center;
-                    } 
-        .def        { font-family: Arial, Verdana, "Times New Roman", Times, serif;}
-        hr.note     { color: #BFBFBF; }
-        .note       { text-align : right; font-style: italic; font-size: small; }
-        div.release { -moz-column-count: 2;
-                      overflow: auto;
-                      max-height: 250px;
-                    }
-        .OK2        { color:#00AA00; }
-	.KO2        { color:#FF0000; }
-    </style>
-       
+      <title>SAlomeTools log</title>
+      <style type="text/css">
+	  table       { width : 100%;
+			margin:1px;
+			padding:1px;
+			border-collapse:collapse;
+			empty-cells : show;
+		      }
+	  td          { vertical-align : center; padding: 15px; }
+	  h1          { text-align : center; }
+	  .legend     { font-weight : bold;
+			text-align : center;
+		      } 
+	  .def        { font-family: Arial, Verdana, "Times New Roman", Times, serif;}
+	  hr.note     { color: #BFBFBF; }
+	  .note       { text-align : right; font-style: italic; font-size: small; }
+	  div.release { -moz-column-count: 2;
+			overflow: auto;
+			max-height: 250px;
+		      }
+	  .OK2        { color:#00AA00; }
+	  .KO2        { color:#FF0000; }
+      </style>
+      <script language="JavaScript"><![CDATA[
+	    function Toggle(id) {
+	      var element = document.getElementById(id);
+
+	      if ( element.style.display == "none" )
+		  element.style.display = "block";
+	      else 
+		  element.style.display = "none";
+	    }
+	  ]]>
+      </script>
 </head>
 	<body class="def" bgcolor="aliceblue">
 		<h1><img src="LOGO-SAT.png"/></h1>
@@ -46,8 +56,17 @@
 			</tr>
 		</table>
 		
-		<h1>command's internal traces</h1>
-		<PRE><xsl:value-of select="SATcommand/Log"/></PRE>
+		<h1>command's internal traces
+		<a href="#">
+		      <xsl:attribute name="onclick">javascript:Toggle('log')</xsl:attribute>
+		      <xsl:attribute name="title">Click to see the command log</xsl:attribute>
+		      collapse / expand
+		</a>
+		</h1>
+		
+		<div style="display:block"><xsl:attribute name="id">log</xsl:attribute>
+		    <PRE><xsl:value-of select="SATcommand/Log"/></PRE>
+		</div>
 		
 		<h1>Links</h1>
 		<table border="1">
diff --git a/src/xsl/test.xsl b/src/xsl/test.xsl
index f517cac..923468d 100644
--- a/src/xsl/test.xsl
+++ b/src/xsl/test.xsl
@@ -74,7 +74,7 @@
                   background: #bbbbbb;
                 }
     span.zero   { color: #A0A0A0; }
-    a.node      { color:#0000FF; text-decoration: none; visited: #FF0000; }
+    a.node      { color: #0000FF }
 
 </style>
 <script language="JavaScript"><![CDATA[
@@ -121,15 +121,15 @@
 
   <h3>Tests</h3>
     
-  <xsl:for-each select="tests/grid">
-    <b>grid <xsl:value-of select="@name" /></b><br/><br/>
+  <xsl:for-each select="tests/testbase">
+    <b>test base <xsl:value-of select="@name" /></b><br/><br/>
     <a name="test"/>
-    <xsl:apply-templates select="." mode="test-grid" />
+    <xsl:apply-templates select="." mode="test-base" />
   </xsl:for-each>
 
 </xsl:template>
 
-<xsl:template match="grid" mode="test-grid">
+<xsl:template match="testbase" mode="test-base">
   <table>
     <!-- Header -->
     <tr bgcolor="#9acd32">
@@ -291,13 +291,13 @@
             <tr>
               <td align="left">
 		    <xsl:attribute name="class"><xsl:value-of select="@res" /></xsl:attribute>
-		    <a href="#content">
+		    <a href="#content" class="node">
 			    <xsl:attribute name="onclick">javascript:Toggle('<xsl:value-of select="@script"/>')</xsl:attribute>
 			    <xsl:attribute name="title">Click to see the script content</xsl:attribute>
 			    <xsl:value-of select="@script" />
 		    </a>
 		    &#160;
-		    <a href="#content">
+		    <a href="#content" class="node">
 			    <xsl:attribute name="onclick">javascript:Toggle('<xsl:value-of select="@script"/>log')</xsl:attribute>
 			    <xsl:attribute name="title">Click to see the execution log</xsl:attribute>
 			    log
@@ -313,13 +313,13 @@
           <xsl:otherwise>
             <tr>
               <td align="left">
-		    <a href="#content">
+		    <a href="#content" class="node">
 			    <xsl:attribute name="onclick">javascript:Toggle('<xsl:value-of select="@script"/>')</xsl:attribute>
 			    <xsl:attribute name="title">Click to see the script content</xsl:attribute>
 			    <xsl:value-of select="@script" />
 		    </a>
 		    &#160;
-		    <a href="#content">
+		    <a href="#content" class="node">
 			    <xsl:attribute name="onclick">javascript:Toggle('<xsl:value-of select="@script"/>log')</xsl:attribute>
 			    <xsl:attribute name="title">Click to see the execution log</xsl:attribute>
 			    log
diff --git a/test/run_all.sh b/test/run_all.sh
index 35fba26..d17df07 100755
--- a/test/run_all.sh
+++ b/test/run_all.sh
@@ -43,6 +43,7 @@ coverage run --source=../commands/config.py,../commands/compile.py,../commands/c
 coverage run --source=../commands/shell.py -a shell/test_shell.py >> test_res.html
 coverage run --source=../commands/job.py -a job/test_job.py >> test_res.html
 coverage run --source=../commands/jobs.py -a jobs/test_jobs.py >> test_res.html
+coverage run --source=../commands/test.py,../src/test_module.py,../src/fork.py -a test/test_command.py >> test_res.html
 echo "****************************"
 echo
 echo "building html coverage"
diff --git a/test/test/test_command.py b/test/test/test_command.py
new file mode 100644
index 0000000..9146376
--- /dev/null
+++ b/test/test/test_command.py
@@ -0,0 +1,102 @@
+#!/usr/bin/env python
+#-*- coding:utf-8 -*-
+#  Copyright (C) 2010-2012  CEA/DEN
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+
+import unittest
+import os
+import sys
+
+# get execution path
+testdir = os.path.dirname(os.path.realpath(__file__))
+sys.path.append(os.path.join(testdir, '..', '..'))
+sys.path.append(os.path.join(testdir, '..', '_testTools'))
+sys.path.append(os.path.join(testdir, '..', '..','commands'))
+
+from salomeTools import Sat
+import HTMLTestRunner
+
+class TestTest(unittest.TestCase):
+    '''Test of the test command
+    '''
+
+    def test_test(self):
+        '''Test the test command
+        '''
+        OK = 'KO'
+        tmp_file = "/tmp/test.txt"
+        application = "SALOME-7.8.0"
+
+        sat = Sat("-l " + tmp_file)
+        
+        # Execute the job command
+        sat.test(application + " --module GEOM --type light" )
+
+        ff = open(tmp_file, "r")
+        log_files = ff.readlines()
+        ff.close()
+        os.remove(tmp_file)
+        log_testboard = [line.replace("\n", "") for line in log_files if 'testboard.xml' in line]
+        
+        text = open(log_testboard[0], "r").read()
+
+        if '<type name="light">' in text:
+            OK = 'OK'         
+        # pyunit method to compare 2 str
+        self.assertEqual(OK, 'OK')
+
+    def test_PY_test(self):
+        '''Test the test command with PY type
+        '''
+        OK = 'KO'
+        tmp_file = "/tmp/test.txt"
+        application = "SALOME-7.8.0"
+
+        sat = Sat("-l " + tmp_file)
+        
+        # Execute the job command
+        sat.test(application + " --module MED --type PY_test_withKernel" )
+
+        ff = open(tmp_file, "r")
+        log_files = ff.readlines()
+        ff.close()
+        os.remove(tmp_file)
+        log_testboard = [line.replace("\n", "") for line in log_files if 'testboard.xml' in line]
+        
+        text = open(log_testboard[0], "r").read()
+
+        if '<type name="light">' in text:
+            OK = 'OK'         
+        # pyunit method to compare 2 str
+        self.assertEqual(OK, 'OK')
+
+    def test_description(self):
+        '''Test the sat -h test
+        '''        
+
+        OK = "KO"
+
+        import test
+        
+        if "The test command runs a test base on a SALOME installation" in test.description():
+            OK = "OK"
+
+        # pyunit method to compare 2 str
+        self.assertEqual(OK, "OK")
+
+# test launch
+if __name__ == '__main__':
+    HTMLTestRunner.main()
-- 
2.39.2