← Back to branch summary

~ubuntu-branches/ubuntu/saucy/drizzle/saucy-proposed

« back to all changes in this revision

Viewing changes to tests/lib/test_mgmt/test_execution.py

  • Committer: Package Import Robot
  • Author(s): Clint Byrum
  • Date: 2012-06-19 10:46:49 UTC
  • mfrom: (1.1.6)
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20120619104649-e2l0ggd4oz3um0f4
Tags: upstream-7.1.36-stable
Import upstream version 7.1.36-stable

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/lib/test_mgmt/test_execution.py
1
1
#! /usr/bin/env python
2
 
# -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
# -*- mode: python; indent-tabs-mode: nil; -*-
3
3
# vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
4
4
#
5
5
# Copyright (C) 2010 Patrick Crews
19
19
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20
20
 
21
21
""" test_execution:
22
 
    code related to the execution of est cases 
 
22
    code related to the execution of test cases 
23
23
    
24
24
    We are provided access to a testManager with 
25
25
    mode-specific testCases.  We contact the executionManager
75
75
        self.current_test_output = None
76
76
        self.current_test_exec_time = 0 
77
77
         
78
 
        if self.debug:
79
 
            self.logging.debug_class(self)
 
78
        self.logging.debug_class(self)
80
79
 
81
80
    def execute(self, start_and_exit):
82
81
        """ Execute a test case.  The details are *very* mode specific """
83
82
        self.status = 1 # we are running
84
83
        keep_running = 1
85
 
        if self.verbose:
86
 
            self.logging.verbose("Executor: %s beginning test execution..." %(self.name))
 
84
        self.logging.verbose("Executor: %s beginning test execution..." %(self.name))
87
85
        while self.test_manager.has_tests() and keep_running == 1:
88
86
            self.get_testCase()
89
87
            for i in range(self.testcase_repeat_count):
90
 
                self.handle_system_reqs()
91
 
                self.handle_server_reqs()
92
 
                self.handle_utility_reqs()
93
 
                self.handle_start_and_exit(start_and_exit)
94
 
                if self.current_test_status != 'fail':
95
 
                    self.execute_testCase()
96
 
                self.record_test_result()
97
 
                if self.current_test_status == 'fail' and not self.execution_manager.force:
98
 
                    self.logging.error("Failed test.  Use --force to execute beyond the first test failure")
99
 
                    keep_running = 0
100
 
                self.current_test_status = None # reset ourselves
 
88
                if keep_running:
 
89
                    self.handle_system_reqs()
 
90
                    self.handle_server_reqs()
 
91
                    self.handle_utility_reqs()
 
92
                    self.handle_start_and_exit(start_and_exit)
 
93
                    if self.current_test_status != 'fail':
 
94
                        self.execute_testCase()
 
95
                    self.record_test_result()
 
96
                    if self.current_test_status == 'fail' and not self.execution_manager.force:
 
97
                        self.logging.error("Failed test.  Use --force to execute beyond the first test failure")
 
98
                        keep_running = 0
 
99
                    self.current_test_status = None # reset ourselves
101
100
        self.status = 0
102
101
 
103
102
    def get_testCase(self):
117
116
        """
118
117
 
119
118
        server_requirements = self.current_testcase.server_requirements
 
119
        cnf_path = self.current_testcase.cnf_path
120
120
        (self.current_servers,bad_start) = self.server_manager.request_servers( self.name
121
121
                                                              , self.workdir
 
122
                                                              , cnf_path
122
123
                                                              , server_requirements
123
124
                                                              , self.working_environment)
124
125
        if self.current_servers == 0 or bad_start:
140
141
                variable_name = "%s_%s" %(self.name.upper(), server.name.upper())
141
142
                variable_value = str(server.master_port)
142
143
                extra_reqs[variable_name] = variable_value
 
144
                variable_name = variable_name + "_PID"
 
145
                variable_value = str(server.pid)
 
146
                extra_reqs[variable_name] = variable_value
143
147
            self.working_environment.update(extra_reqs)
144
148
        return 
145
149
 
194
198
 
195
199
    def execute_testCase(self):
196
200
        """ Do whatever evil voodoo we must do to execute a testCase """
197
 
        if self.verbose:
198
 
            self.logging.verbose("Executor: %s executing test: %s" %(self.name, self.current_testcase.fullname))
 
201
        self.logging.verbose("Executor: %s executing test: %s" %(self.name, self.current_testcase.fullname))
199
202
 
200
203
    def record_test_result(self):
201
204
        """ We get the test_manager to record the result """
220
223
            method
221
224
 
222
225
        """
223
 
        
 
226
 
 
227
        self.process_environment_reqs()
 
228
        self.process_symlink_reqs()
 
229
        self.process_master_sh()  
224
230
        return
225
231
 
 
232
    def process_master_sh(self):
 
233
        """ We do what we need to if we have a master.sh file """
 
234
        if self.current_testcase.master_sh:
 
235
            retcode, output = self.system_manager.execute_cmd("/bin/sh %s" %(self.current_testcase.master_sh))
 
236
            self.logging.debug("retcode: %retcode")
 
237
            self.logging.debug("%output")
 
238
 
 
239
    def process_environment_reqs(self):
 
240
        """ We generate the ENV vars we need set
 
241
            and then ask systemManager to do so
 
242
 
 
243
        """
 
244
        # We need to have a default set / file / whatever based
 
245
        # on the dbqp config file / what we're using dbqp for
 
246
        # will move this dict elsewhere to make this method more generic
 
247
 
 
248
        env_reqs = { 'DRIZZLETEST_VARDIR': self.master_server.vardir
 
249
                   ,  'DRIZZLE_TMP_DIR': self.master_server.tmpdir
 
250
                   ,  'MASTER_MYSOCK': self.master_server.socket_file
 
251
                   ,  'MASTER_MYPORT': str(self.master_server.master_port)
 
252
                   ,  'MC_PORT': str(self.master_server.mc_port)
 
253
                   ,  'PBMS_PORT': str(self.master_server.pbms_port)
 
254
                   ,  'JSON_SERVER_PORT': str(self.master_server.json_server_port)
 
255
                   ,  'RABBITMQ_NODE_PORT': str(self.master_server.rabbitmq_node_port)
 
256
                   ,  'DRIZZLE_TCP_PORT': str(self.master_server.drizzle_tcp_port)
 
257
                   ,  'EXE_DRIZZLE': self.master_server.drizzle_client
 
258
                   ,  'MASTER_SERVER_SLAVE_CONFIG' : self.master_server.slave_config_file
 
259
                   ,  'DRIZZLE_DUMP': "%s --no-defaults -uroot -p%d" %( self.master_server.drizzledump
 
260
                                                        , self.master_server.master_port)
 
261
                   ,  'DRIZZLE_SLAP': "%s -uroot -p%d" %( self.master_server.drizzleslap
 
262
                                                        , self.master_server.master_port)
 
263
                   ,  'DRIZZLE_IMPORT': "%s -uroot -p%d" %( self.master_server.drizzleimport
 
264
                                                          , self.master_server.master_port)
 
265
                   ,  'DRIZZLE': "%s -uroot -p%d" %( self.master_server.drizzle_client
 
266
                                                   , self.master_server.master_port)
 
267
                   ,  'DRIZZLE_BASEDIR' : self.system_manager.code_manager.code_trees['drizzle'][0].basedir
 
268
                   ,  'DRIZZLE_TEST_WORKDIR' : self.system_manager.workdir
 
269
                   }     
 
270
 
 
271
        self.working_environment = self.system_manager.env_manager.create_working_environment(env_reqs)
 
272
 
 
273
    def process_symlink_reqs(self):
 
274
        """ Create any symlinks we may need """
 
275
        needed_symlinks = []
 
276
 
 
277
        self.system_manager.create_symlinks(needed_symlinks)
 
278
 
 
279
    
 
280
   
 
281
 
 
282
 
226
283