Moving Test related code to parent class Test

test/lib/tarantool_server.py

@@ -49,48 +49,8 @@ def create_tmpfs_vardir(vardir):
     os.symlink(os.path.join("/dev/shm", vardir), vardir)
 
 class FuncTest(Test):
-    def __init__(self, name, args, suite_ini):
-        Test.__init__(self, name, args, suite_ini)
-        self.name = name
-        self.result = name.replace(".test", ".result")
-        self.skip_cond = name.replace(".test", ".skipcond")
-        self.tmp_result = os.path.join(self.args.vardir,
-                os.path.basename(self.result))
-        self.reject = "{0}/test/{1}".format(self.args.builddir,
-                name.replace(".test", ".reject"))
-
     def execute(self, server):
-        diagnostics = "unknown"
-        builddir = self.args.builddir
-        save_stdout = sys.stdout
-        try:
-            self.skip = 0
-            if os.path.exists(self.skip_cond):
-                sys.stdout = FilteredStream(self.tmp_result)
-                stdout_fileno = sys.stdout.stream.fileno()
-                execfile(self.skip_cond, dict(locals(), **server.__dict__))
-                sys.stdout.close()
-                sys.stdout = save_stdout
-            if not self.skip:
-                sys.stdout = FilteredStream(self.tmp_result)
-                stdout_fileno = sys.stdout.stream.fileno()
-                execfile(self.name, dict(locals(), **server.__dict__))
-            self.is_executed_ok = True
-        except Exception as e:
-            traceback.print_exc(e)
-            diagnostics = str(e)
-        finally:
-            if sys.stdout and sys.stdout != save_stdout:
-                sys.stdout.close()
-            sys.stdout = save_stdout;
-        self.is_executed = True
-
-    def __repr__(self):
-        return str([self.name, self.result, self.skip_cond, self.tmp_result,
-        self.reject])
-
-    __str__ = __repr__
-
+        execfile(self.name, dict(locals(), **server.__dict__))
 
 class TarantoolConfigFile:
     """ConfigParser can't read files without sections, work it around"""
@@ -140,10 +100,11 @@ class TarantoolServer(Server):
 
     def find_exe(self, builddir, silent=True):
         "Locate server executable in the build dir or in the PATH."
+        self.builddir = builddir
         builddir = os.path.join(builddir, "src/box")
         path = builddir + os.pathsep + os.environ["PATH"]
         if not silent:
-            print "  Looking for server binary in {0} ...".format(path)
+            print "Looking for server binary in {0} ...".format(path)
         for dir in path.split(os.pathsep):
             exe = os.path.join(dir, self.default_bin_name)
             if os.access(exe, os.X_OK):
@@ -179,30 +140,36 @@ class TarantoolServer(Server):
             else:
                 os.makedirs(self.vardir)
 
-        shutil.copy(self.config, os.path.join(self.vardir,
-                                              self.default_config_name))
+        shutil.copy(self.config, 
+                    os.path.join(self.vardir, self.default_config_name))
         shutil.copy(self.valgrind_sup,
                     os.path.join(self.vardir, self.default_suppression_name))
 
         var_init_lua = os.path.join(self.vardir, self.default_init_lua_name)
         if self.init_lua != None:
+            if os.path.exists(var_init_lua):
+                os.remove(var_init_lua)
             shutil.copy(self.init_lua, var_init_lua)
-        elif os.path.exists(var_init_lua):
-            # We must delete old init.lua if it exists
-            os.remove(var_init_lua)
+
 
     def configure(self, config):
+        def get_option(config, section, key):
+            value = config.get(section, key)
+            if value.isdigit():
+                value = int(value)
+            return value
+            config.get()
         self.config = os.path.abspath(config)
         # now read the server config, we need some properties from it
         with open(self.config) as fp:
             dummy_section_name = "tarantool"
             config = ConfigParser.ConfigParser()
             config.readfp(TarantoolConfigFile(fp, dummy_section_name))
-
-            self.pidfile = config.get(dummy_section_name, "pid_file")
-            self.primary_port = self.get_option_int(config, dummy_section_name, "primary_port")
-            self.admin_port = self.get_option_int(config, dummy_section_name, "admin_port")
-            self.memcached_port = self.get_option_int(config, dummy_section_name, "memcached_port")
+        
+            self.pidfile = get_option(config, dummy_section_name, "pid_file")
+            self.primary_port = get_option(config, dummy_section_name, "primary_port")
+            self.admin_port = get_option(config, dummy_section_name, "admin_port")
+            self.memcached_port = get_option(config, dummy_section_name, "memcached_port")
 
         self.port = self.admin_port
         self.admin = AdminConnection("localhost", self.admin_port)
@@ -240,9 +207,13 @@ class TarantoolServer(Server):
                               stderr = subprocess.PIPE)
 
     def get_param(self, param):
-        data = self.admin.execute("show info", silent = True)
-        info = yaml.load(data)["info"]
-        return info[param]
+        if param != None:
+            data = self.admin("show.info."+param)
+            info = yaml.load(data)
+        else:
+            data = self.admin.execute("show info", silent = True)
+            info = yaml.load(data)["info"]
+        return info
 
     def wait_lsn(self, lsn):
         while True:
@@ -265,7 +236,7 @@ class TarantoolServer(Server):
 
         if self.valgrind:
             with daemon.DaemonContext(working_directory = self.vardir):
-                subprocess.check_call(args)
+                subprocess.check_call(arg   s)
         else:
             if not self.gdb:
                 args.append("--background")

test/lib/test_suite.py

@@ -96,7 +96,6 @@ class Test:
 
     def passed(self):
         """Return true if this test was run successfully."""
-
         return self.is_executed and self.is_executed_ok and self.is_equal_result
 
     def run(self, server):
@@ -106,11 +105,28 @@ class Test:
         If there is a difference, print it to stdout and raise an
         exception. The exception is raised only if is_force flag is
         not set."""
-
-
         diagnostics = "unknown"
-        builddir = self.args.builddir
-        self.execute(server)
+        save_stdout = sys.stdout
+        try:
+            self.skip = 0
+            if os.path.exists(self.skip_cond):
+                sys.stdout = FilteredStream(self.tmp_result)
+                stdout_fileno = sys.stdout.stream.fileno()
+                execfile(self.skip_cond, dict(locals(), **server.__dict__))
+                sys.stdout.close()
+                sys.stdout = save_stdout
+            if not self.skip:
+                sys.stdout = FilteredStream(self.tmp_result)
+                stdout_fileno = sys.stdout.stream.fileno()
+                self.execute(server)
+            self.is_executed_ok = True
+        except Exception as e:
+            traceback.print_exc(e)
+            diagnostics = str(e)
+        finally:
+            if sys.stdout and sys.stdout != save_stdout:
+                sys.stdout.close()
+            sys.stdout = save_stdout;
         self.is_executed = True
 
         if not self.skip:

test/lib/unittest_server.py

 import os
 import re
 import sys
+import glob
 import traceback
 import subprocess
-
 from subprocess import Popen, PIPE
 
-
 from server import Server
 from test_suite import FilteredStream, Test
 
-
 class UnitTest(Test):
-    def __init__(self, name, args, suite_ini):
-        Test.__init__(self, name, args, suite_ini)
-        self.name = name + ".test"
-        self.result = name + ".result"
-        self.skip_cond = name + ".skipcond"
-        self.tmp_result = os.path.join(self.args.vardir,
-                                       os.path.basename(self.result))
-        self.reject = "{0}/test/{1}".format(self.args.builddir, name + ".reject")
-
     def execute(self, server):
-        diagnostics = "unknown"
-        builddir = self.args.builddir
-        save_stdout = sys.stdout
-        try:
-            self.skip = 0
-            if os.path.exists(self.skip_cond):
-                sys.stdout = FilteredStream(self.tmp_result)
-                stdout_fileno = sys.stdout.stream.fileno()
-                execfile(self.skip_cond, dict(locals(), **server.__dict__))
-                sys.stdout.close()
-                sys.stdout = save_stdout
-            if not self.skip:
-                sys.stdout = FilteredStream(self.tmp_result)
-                stdout_fileno = sys.stdout.stream.fileno()
-                execs = [os.path.join(server.builddir, "test", self.name)]
-                proc = Popen(execs, stdout=PIPE)
-                sys.stdout.write(proc.communicate()[0])
-            self.is_executed_ok = True
-        except Exception as e:
-            traceback.print_exc(e)
-            diagnostics = str(e)
-        finally:
-            if sys.stdout and sys.stdout != save_stdout:
-                sys.stdout.close()
-            sys.stdout = save_stdout;
-        self.is_executed = True
-
-    def __repr__(self):
-        return str([self.name, self.result, self.skip_cond, self.tmp_result,
-        self.reject])
-
-    __str__ = __repr__
-
+        execs = [os.path.join(server.builddir, "test", self.name)]
+        proc = Popen(execs, stdout=PIPE)
+        sys.stdout.write(proc.communicate()[0])
 
 class UnittestServer(Server):
     """A dummy server implementation for unit test suite"""
     def __new__(cls, core="unittest"):
         return Server.__new__(cls)
 
-
     def __init__(self, core="unittest"):
         Server.__init__(self, core)
         self.debug = False
 
-    def configure(self, config):
-        pass
     def deploy(self, config=None, binary=None, vardir=None,
                mem=None, start_and_exit=None, gdb=None, valgrind=None,
                valgrind_sup=None, init_lua=None, silent=True, need_init=True):
-
         self.vardir = vardir
         if not os.access(self.vardir, os.F_OK):
-            if (self.mem == True and check_tmpfs_exists() and
-                os.path.basename(self.vardir) == self.vardir):
-                create_tmpfs_vardir(self.vardir)
-            else:
-                os.makedirs(self.vardir)
-
+            os.makedirs(self.vardir)
 
-    def start(self):
-        pass
     def find_exe(self, builddir, silent=False):
         self.builddir = builddir
 
@@ -92,15 +40,7 @@ class UnittestServer(Server):
                 if name.find(i) != -1:
                     return True
             return False
-
-        regexp = re.compile('([a-zA-Z0-9_]*).test')
-        for f in sorted(os.listdir(suite_path)):
-            if regexp.match(f):
-                f = os.path.join(suite_path, regexp.match(f).groups()[0]) + '.test'
-                if os.access(f, os.X_OK) and os.path.isfile(f) and patterned(f):
-                    test_suite.tests.append(UnitTest(f[:-5], test_suite.args,
-                                test_suite.ini));
-
-
-    def init(self):
-        pass
+        for f in sorted(glob.glob(os.path.join(suite_path, '*.test'))):
+            if os.access(f, os.X_OK) and os.path.isfile(f) and patterned(f):
+                test_suite.tests.append(UnitTest(f, test_suite.args,
+                            test_suite.ini));