← Back to branch summary

~drizzle-developers/drizzle/elliott-release

« back to all changes in this revision

Viewing changes to tests/lib/drizzle_test_run/dtr_test_execution.py

  • Committer: Patrick Crews
  • Date: 2011-02-01 20:33:06 UTC
  • mfrom: (1845.2.288 drizzle)
  • Revision ID: gleebix@gmail.com-20110201203306-mwq2rk0it81tlwxh
Merged Trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/lib/drizzle_test_run/dtr_test_execution.py
 
1
#! /usr/bin/python
 
2
# -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
3
# vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
4
#
 
5
# Copyright (C) 2010 Patrick Crews
 
6
#
 
7
#
 
8
# This program is free software; you can redistribute it and/or modify
 
9
# it under the terms of the GNU General Public License as published by
 
10
# the Free Software Foundation; either version 2 of the License, or
 
11
# (at your option) any later version.
 
12
#
 
13
# This program is distributed in the hope that it will be useful,
 
14
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
16
# GNU General Public License for more details.
 
17
#
 
18
# You should have received a copy of the GNU General Public License
 
19
# along with this program; if not, write to the Free Software
 
20
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
21
 
 
22
""" dtr_test_execution:
 
23
    code related to the execution of dtr test cases 
 
24
    
 
25
    We are provided access to a testManager with 
 
26
    dtr-specific testCases.  We contact teh executionManager
 
27
    to produce the system and server configurations we need
 
28
    to execute a test.
 
29
 
 
30
"""
 
31
 
 
32
# imports
 
33
import os
 
34
import sys
 
35
import subprocess
 
36
import commands
 
37
 
 
38
import lib.test_mgmt.test_execution as test_execution
 
39
 
 
40
class dtrTestExecutor(test_execution.testExecutor):
 
41
    """ dtr-specific testExecutor 
 
42
        We currently execute by sending test-case
 
43
        data to client/drizzletest...for now
 
44
 
 
45
    """
 
46
  
 
47
    def execute_testCase (self):
 
48
        """ Execute a dtr testCase via calls to drizzletest (boo)
 
49
            Eventually, we will replace drizzletest with pythonic
 
50
            goodness, but we have these classes stored here for the moment
 
51
 
 
52
        """
 
53
        test_execution.testExecutor.execute_testCase(self)
 
54
        self.status = 0
 
55
 
 
56
        # generate command line
 
57
        drizzletest_cmd = self.generate_drizzletest_call()
 
58
        if self.debug:
 
59
            self.logging.debug(drizzletest_cmd)
 
60
 
 
61
        # call drizzletest
 
62
        self.process_symlink_reqs()
 
63
        self.process_environment_reqs()
 
64
        self.execute_drizzletest(drizzletest_cmd)
 
65
 
 
66
        # analyze results
 
67
        self.current_test_status = self.process_drizzletest_output()
 
68
        self.set_server_status(self.current_test_status)
 
69
 
 
70
 
 
71
    def generate_drizzletest_call(self):
 
72
        """ Produce the command line we use to call drizzletest
 
73
            We have a healthy number of values, so we put this in a 
 
74
            nice function
 
75
 
 
76
        """
 
77
 
 
78
        drizzletest_arguments = [ '--no-defaults'
 
79
                                , '--silent'
 
80
                                , '--tmpdir=%s' %(self.master_server.tmpdir)
 
81
                                , '--logdir=%s' %(self.master_server.logdir)
 
82
                                , '--port=%d' %(self.master_server.master_port)
 
83
                                , '--database=test'
 
84
                                , '--user=root'
 
85
                                , '--password='
 
86
                                #, '--testdir=%s' %(self.test_manager.testdir)
 
87
                                , '--test-file=%s' %(self.current_testcase.testpath)
 
88
                                , '--tail-lines=20'
 
89
                                , '--timer-file=%s' %(self.master_server.timer_file)
 
90
                                , '--result-file=%s' %(self.current_testcase.resultpath)
 
91
                                ]
 
92
        if self.record_flag:
 
93
            # We want to record a new result
 
94
            drizzletest_arguments.append('--record')
 
95
        drizzletest_cmd = "%s %s %s" %( self.cmd_prefix
 
96
                                      , self.system_manager.code_tree.drizzletest
 
97
                                      , " ".join(drizzletest_arguments))
 
98
        return drizzletest_cmd
 
99
 
 
100
    def execute_drizzletest(self, drizzletest_cmd):
 
101
        """ Execute the commandline and return the result.
 
102
            We use subprocess as we can pass os.environ dicts and whatnot 
 
103
 
 
104
        """
 
105
        testcase_name = self.current_testcase.fullname
 
106
        self.time_manager.start(testcase_name,'test')
 
107
        retcode, output = self.system_manager.execute_cmd( drizzletest_cmd
 
108
                                                         , must_pass = 0 )
 
109
        execution_time = int(self.time_manager.stop(testcase_name)*1000) # millisec
 
110
 
 
111
        if self.debug:
 
112
            self.logging.debug("drizzletest_retcode: %d" %(retcode))
 
113
            self.logging.debug("drizzletest_output: %s" %(output))
 
114
        self.current_test_retcode = retcode
 
115
        self.current_test_output = output
 
116
        self.current_test_exec_time = execution_time
 
117
 
 
118
    def process_drizzletest_output(self):
 
119
        """ Drizzletest has run, we now check out what we have """
 
120
        retcode = self.current_test_retcode
 
121
        if retcode == 0:
 
122
            return 'pass'
 
123
        elif retcode == 62 or retcode == 15872:
 
124
            return 'skipped'
 
125
        elif retcode == 63 or retcode == 1:
 
126
            return 'fail'
 
127
        else:
 
128
            return 'fail'
 
129
 
 
130
    def process_environment_reqs(self):
 
131
        """ We generate the ENV vars we need set
 
132
            and then ask systemManager to do so
 
133
 
 
134
        """
 
135
        
 
136
        env_reqs = { 'DRIZZLETEST_VARDIR': (self.master_server.vardir,0,0)
 
137
                   ,  'DRIZZLE_TMP_DIR': (self.master_server.tmpdir,0,0)
 
138
                   ,  'MASTER_MYSOCK': (self.master_server.socket_file,0,0)
 
139
                   ,  'MASTER_MYPORT': (str(self.master_server.master_port),0,0)
 
140
                   ,  'MC_PORT': (str(self.master_server.mc_port),0,0)
 
141
                   ,  'PBMS_PORT': (str(self.master_server.pbms_port),0,0)
 
142
                   ,  'DRIZZLE_TCP_PORT': (str(self.master_server.drizzle_tcp_port),0,0)
 
143
                   ,  'EXE_DRIZZLE': (self.master_server.drizzle_client,0,0)
 
144
                   ,  'DRIZZLE_DUMP': ("%s --no-defaults -uroot -p%d" %( self.master_server.drizzledump
 
145
                                                        , self.master_server.master_port),0,0)
 
146
                   ,  'DRIZZLE_SLAP': ("%s -uroot -p%d" %( self.master_server.drizzleslap
 
147
                                                        , self.master_server.master_port),0,0)
 
148
                   ,  'DRIZZLE_IMPORT': ("%s -uroot -p%d" %( self.master_server.drizzleimport
 
149
                                                          , self.master_server.master_port),0,0)
 
150
                   ,  'DRIZZLE': ("%s -uroot -p%d" %( self.master_server.drizzle_client
 
151
                                                   , self.master_server.master_port),0,0)
 
152
                   ,  'DRIZZLE_ADMIN' : ("%s -uroot -p%d" %( self.master_server.drizzleadmin
 
153
                                                         , self.master_server.master_port),0,0)
 
154
                   }     
 
155
 
 
156
        self.system_manager.process_environment_reqs(env_reqs, quiet=1)
 
157
 
 
158
    def process_symlink_reqs(self):
 
159
        """ Create any symlinks we may need """
 
160
        needed_symlinks = []
 
161
 
 
162
        # handle filesystem_engine 
 
163
        if self.current_testcase.suitename == 'filesystem_engine':
 
164
            needed_symlinks.append(( os.path.join(self.current_testcase.suitepath
 
165
                                  , 't')
 
166
                                  , os.path.join(self.master_server.vardir
 
167
                                  , "filesystem_ln")))
 
168
 
 
169
        self.system_manager.create_symlinks(needed_symlinks)
 
170
 
 
171
    
 
172
   
 
173
 
 
174