class ReporterPlugin(nose.plugins.Plugin): """ handle test output. """ name = 'reporter' #score = 200 def __init__(self, counter=None, report_client=None, timer=None): super(ReporterPlugin, self).__init__() self.__report_client = report_client if report_client else None self.__counter = counter self.__timer = timer self.__log_handler = None self.__configuration = {} def options(self, parser, env): """ Register commandline options. Called to allow plugin to register command line options with the parser. DO NOT return a value from this method unless you want to stop all other plugins from setting their options. """ super(ReporterPlugin, self).options(parser, env) ###local ouput result config### parser.add_option('--file-name', dest='file_name', default='result.txt', help="save output file to this directory") parser.add_option( '--directory', action='store_true', dest='directory', default=self.__getDefault(), help= "save output file to this directory. default is current nose worspace" ) parser.add_option('--icycle', action='store', type='string', metavar="STRING", dest='icycle', default=None, help="total cycle flag") ###report server config### parser.add_option( '--reportserver', action='store_true', dest='reportserver', default=False, help= "switcher of uploading result to server. default is enable the feature" ) parser.add_option('--server-config', action='store', metavar="FILE", dest='server_config', default='server.config', help="specify the server config file path") parser.add_option('--device-config', action='store', metavar="FILE", dest='device_config', default='device.config', help="specify the device config file path") parser.add_option( '--duration', dest='duration', type='string', metavar="STRING", action='callback', callback=self.__validate_duration, help='The minumum test duration before ending the test.\ Here format must follow next format: xxDxxHxxMxxS.\ e.g. --duration=2D09H30M12S, which means 2 days, 09 hours, 30 minutes and 12 seconds' ) def __validate_duration(self, option, opt, value, parser): ''' ''' value = string.lower(value) begin = 0 days = hours = minutes = seconds = 0 for i, v in enumerate(value): if v == 'd': days = int(value[begin:i]) begin = i + 1 elif v == 'h': hours = int(value[begin:i]) begin = i + 1 elif v == 'm': minutes = int(value[begin:i]) begin = i + 1 elif v == 's': seconds = int(value[begin:i]) begin = i + 1 if begin == 0: parser.error('%s: duration format error' % value) times = datetime.timedelta(days=days, hours=hours, minutes=minutes, seconds=seconds) setattr(parser.values, option.dest, times) def __getDefault(self): workspace = os.getcwd() if 'WORKSPACE' in os.environ: ws = os.environ['WORKSPACE'] workspace = _mkdir(ws) return workspace def configure(self, options, conf): """ Called after the command line has been parsed, with the parsed options and the config container. Here, implement any config storage or changes to state or operation that are set by command line options. DO NOT return a value from this method unless you want to stop all other plugins from being configured. """ super(ReporterPlugin, self).configure(options, conf) if not self.enabled: return self.write_hashes = conf.verbosity == 2 self.conf = conf self.opt = options if self.opt.icycle and not self.__counter: self.__counter = TestCounter(cycles=self.opt.icycle) elif not self.__counter: self.__counter = TestCounter() if self.opt.duration and not self.__timer: self.__timer = Timer(self.opt.duration) if not self.__configuration: if self.opt.reportserver: if not exists(options.server_config): raise Exception( 'exit due to unable to find server configuration file: "%s"' % options.server_config) if not exists(options.device_config): raise Exception( 'exit due to unable to find device configuration file: "%s"' % options.device_config) self.__configuration.update( _getServerConfiguration(options.server_config)) self.__configuration.update( _getDeviceConfiguration(options.device_config)) self.__configuration.update( {'planname': os.path.basename(self.conf.options.plan_file)}) self.result_properties = {'payload': None, 'extras': None} #if disable report server if self.opt.reportserver and not self.__report_client: server_need = { 'username': None, 'password': None, 'auth': None, 'session_create': None, 'session_update': None, 'case_create': None, 'case_update': None, 'file_upload': None } self.__report_client = ReportClient(**self.__configuration) self.token = self.__report_client.regist() if not self.token: raise Exception('exit due to unable to get token from server!') #used to add local report if need #self.result_file = join(_mkdir(self.opt.directory), self.opt.file_name) def setOutputStream(self, stream): """ Get handle on output stream so the plugin can print id #n """ self.stream = stream def __write(self, output): ''' Write output as content ''' try: self.stream.write(output) except: pass def prepareTest(self, test): ''' enable log handler. ''' if not self.__log_handler: self.__log_handler = LogHandler( serial=self.__configuration['deviceid']) if not self.__log_handler.available(): self.__log_handler.start() def begin(self): self.session_id = self.__counter.sid self.test_start_time = getattr(self, 'test_start_time', None) if not self.test_start_time: self.test_start_time = _reportTime() self.opt.directory = self.conf.workingDir self._report_path = _mkdir( join(join(self.opt.directory, 'report'), str(self.test_start_time).replace(' ', '_'))) self._pass_report_path = _mkdir(join(self._report_path, 'pass')) self._fail_report_path = _mkdir(join(self._report_path, 'fail')) self._error_report_path = _mkdir(join(self._report_path, 'error')) self._timeout_report_path = _mkdir(join(self._report_path, 'timeout')) session_properties = { 'sid': self.session_id, 'starttime': self.test_start_time } self.cid = self.__counter.next_cid() if self.write_hashes: sys.stderr.write('begin cycle: %s \n' % (self.cid)) if self.opt.reportserver and not self.__report_client.created: self.__report_client.createSession(**session_properties) def __setTestCaseContext(self, test): module_name, class_name, method_name = test.id().split('.')[-3:] ctx = TestCaseContext(self._fail_report_path, self._error_report_path) ctx.case_dir_name = '%s%s%s' % (class_name, '.', method_name) ctx.device_config = self.__configuration setattr(test.context, 'contexts', ctx) def __getTestCaseContext(self, test): return getattr(test.context, 'contexts') def prepareTestCase(self, test): self.__setTestCaseContext(test) def startTest(self, test): """ startTest: called after beforeTest(*) """ self.tid = self.__counter.next_tid() ctx = self.__getTestCaseContext(test) ctx.case_start_time = _reportTime() ctx.user_log_dir = join(ctx.case_report_tmp_dir, 'logs') path = _mkdir(ctx.user_log_dir) if self.write_hashes: self.__write('#%s %s ' % (str(self.tid), str(ctx.case_start_time))) def handleFailure(self, test, err): ''' Called on addFailure. To handle the failure yourself and prevent normal failure processing, return a true value. ''' self.result_properties.clear() exctype, value, tb = err try: ctx = self.__getTestCaseContext(test) log_file = join(ctx.user_log_dir, LOG_FILE_NAME) self.__log_handler.save(log_file) #makeLog(ctx.user_log_dir) #shutil.move(ctx.case_report_tmp_dir, self._fail_report_path) except: pass self.result_properties.update({ 'extras': { 'screenshot_at_failure': ctx.fail_screenshot_at_failure, 'log': ctx.fail_log, 'expect': ctx.expect, } }) def handleError(self, test, err): ''' Called on addError. To handle the failure yourself and prevent normal error processing, return a true value. ''' self.result_properties.clear() try: ctx = self.__getTestCaseContext(test) log_file = join(ctx.user_log_dir, LOG_FILE_NAME) self.__log_handler.save(log_file) #makeLog(ctx.user_log_dir) except: pass self.result_properties.update({ 'extras': { 'screenshot_at_failure': ctx.error_screenshot_at_failure, 'log': ctx.error_log, 'expect': ctx.expect, } }) def addFailure(self, test, err, capt=None, tbinfo=None): ctx = self.__getTestCaseContext(test) ctx.case_end_time = _reportTime() #payload data self.result_properties.update({ 'payload': { 'tid': self.tid, 'casename': ctx.case_dir_name, 'starttime': ctx.case_start_time, 'endtime': ctx.case_end_time, 'result': 'fail', 'trace': _formatOutput(ctx.case_dir_name, 'fail', err) } }) trace_log_path = join(ctx.user_log_dir, 'trace.txt') with open(trace_log_path, 'w+') as f: f.write(str(self.result_properties['payload']['trace'])) _makeLog(path=ctx.user_log_dir, serial=self.__configuration['deviceid']) try: shutil.move(ctx.case_report_tmp_dir, self._fail_report_path) except: pass if self.__timer and not self.__timer.alive(): self.conf.stopOnError = True if self.opt.reportserver: self.__report_client.updateTestCase(**self.result_properties) #remote upload def addError(self, test, err, capt=None): ctx = self.__getTestCaseContext(test) ctx.case_end_time = _reportTime() self.result_properties.update({ 'payload': { 'tid': self.tid, 'casename': ctx.case_dir_name, 'starttime': ctx.case_start_time, 'endtime': ctx.case_end_time, 'result': 'error', 'trace': _formatOutput(ctx.case_dir_name, 'error', err) } }) trace_log_path = join(ctx.user_log_dir, 'trace.txt') with open(trace_log_path, 'w+') as f: f.write(str(self.result_properties['payload']['trace'])) _makeLog(path=ctx.user_log_dir, serial=self.__configuration['deviceid']) try: shutil.move(ctx.case_report_tmp_dir, self._error_report_path) except: pass if self.__timer and not self.__timer.alive(): self.conf.stopOnError = True if self.opt.reportserver: self.__report_client.updateTestCase(**self.result_properties) #remote upload def addSuccess(self, test, capt=None): ctx = self.__getTestCaseContext(test) ctx.case_end_time = _reportTime() self.result_properties.clear() self.result_properties.update({ 'payload': { 'tid': self.tid, 'casename': ctx.case_dir_name, 'starttime': ctx.case_start_time, 'endtime': ctx.case_end_time, 'result': 'pass' } }) #self.__log_handler.drop() log_file = join(ctx.user_log_dir, LOG_FILE_NAME) self.__log_handler.save(log_file) trace_log_path = join(ctx.user_log_dir, 'trace.txt') with open(trace_log_path, 'w+') as f: f.write(str(self.result_properties['payload']['result'])) _makeLog(path=ctx.user_log_dir, serial=self.__configuration['deviceid'], result='pass') try: shutil.move(ctx.case_report_tmp_dir, self._pass_report_path) except: pass if self.__timer and not self.__timer.alive(): self.conf.stopOnError = True if self.opt.reportserver: self.__report_client.updateTestCase(**self.result_properties) def report(self, stream): session_properties = {'sid': self.session_id} if self.opt.duration and self.__timer: session_properties.update({'status': self.__timer.progress()}) elif self.opt.icycle and self.__counter: session_properties.update({'status': self.__counter.progress()}) if self.opt.reportserver: self.__report_client.updateSession(**session_properties) return None def finalize(self, result): if self.write_hashes: self.__write('end cycle: %s \n' % (self.cid)) session_properties = {'sid': self.session_id} if self.opt.icycle and not self.__counter.alive( ) and self.opt.reportserver: session_properties.update({'endtime': _reportTime()}) self.__report_client.updateSession(**session_properties) if self.conf.stopOnError and self.opt.reportserver: session_properties.update({'endtime': _reportTime()}) self.__report_client.updateSession(**session_properties) sys.exit(1) return None
class ReporterPlugin(nose.plugins.Plugin): """ Write test result to $WORKSPACE/result.txt or ./result.txt """ name = 'reporter' #score = 200 def __init__(self, counter=None, report_client=None): super(ReporterPlugin, self).__init__() self.__counter = counter if counter else TestCounter() self.__report_client = report_client if report_client else None def options(self, parser, env): """ Register commandline options. Called to allow plugin to register command line options with the parser. DO NOT return a value from this method unless you want to stop all other plugins from setting their options. """ super(ReporterPlugin, self).options(parser, env) ###local ouput result config### parser.add_option('--file-name', dest='file_name', default='result.txt', help="save output file to this directory") parser.add_option('--directory', action='store_true', dest='directory', default=self.getDefault(), help="save output file to this directory. default is current nose worspace") parser.add_option('--size', action='store', metavar="FILE", dest='server_config', default=4096, help="file size limit") ###report server config### parser.add_option('--reportserver', action='store_true', dest='reportserver', default=False, help="switcher of uploading result to server. default is enable the feature") parser.add_option('--server-config', action='store', metavar="FILE", dest='server_config', default='server.config', help="specify the server config file path") def getDefault(self): workspace = os.getcwd() if 'WORKSPACE' in os.environ: ws = os.environ['WORKSPACE'] workspace = _mkdir(ws) return workspace def configure(self, options, conf): """ Called after the command line has been parsed, with the parsed options and the config container. Here, implement any config storage or changes to state or operation that are set by command line options. DO NOT return a value from this method unless you want to stop all other plugins from being configured. """ super(ReporterPlugin, self).configure(options, conf) if not self.enabled: return self.write_hashes = conf.verbosity == 2 self.conf = conf self.opt = options self.result_properties = {'payload': None, 'extras': None} #if disable report server if self.opt.reportserver and not self.__report_client: server_need = {'username':None, 'password':None, 'auth':None, 'session_create':None, 'session_update':None, 'case_create':None, 'case_update':None, 'file_upload':None} if not exists(options.server_config): raise Exception('exit due to unable to find server config file!') self.__report_client = ReportClient(config=options.server_config) self.token = self.__report_client.regist() if not self.token: raise Exception('exit due to unable to get token from server!') #used to add local report if need #self.result_file = join(_mkdir(self.opt.directory), self.opt.file_name) def setOutputStream(self, stream): """ Get handle on output stream so the plugin can print id #n """ self.stream = stream def _write(self, output): ''' Write output as content ''' try: self.stream.write(output) except: pass def begin(self): self.session_id = self.__counter.sid self.test_start_time = getattr(self, 'test_start_time', None) if not self.test_start_time: self.test_start_time = reporttime() self._report_path = _mkdir(join(join(self.opt.directory, 'report'), str(self.test_start_time).replace(' ', '_'))) self._all_report_path = _mkdir(join(self._report_path, 'all')) self._fail_report_path = _mkdir(join(self._report_path, 'fail')) self._error_report_path = _mkdir(join(self._report_path, 'error')) self._timeout_report_path = _mkdir(join(self._report_path, 'timeout')) session_properties = {'sid': self.session_id, 'starttime': self.test_start_time } if self.opt.reportserver and not self.__report_client.created: self.__report_client.createSession(**session_properties) def setTestCaseContext(self, test): module_name, class_name, method_name = test.id().split('.')[-3:] ctx = TestCaseContext(self._fail_report_path, self._error_report_path) ctx.case_dir_name = '%s%s%s' % (class_name, '.', method_name) setattr(test.context, 'contexts', ctx) def getTestCaseContext(self, test): return getattr(test.context, 'contexts') def prepareTestCase(self, test): #sys.stderr.write('------------------------------prepareTestCase-------------\n') self.setTestCaseContext(test) def startTest(self, test): """ startTest: called after beforeTest(*) """ self.tid = self.__counter.next() ctx = self.getTestCaseContext(test) ctx.case_start_time = reporttime() ctx.user_log_dir = join(ctx.case_report_tmp_dir, 'logs') if self.write_hashes: self._write('#%s %s ' % (str(self.tid), str(ctx.case_start_time))) def stopTest(self, test): """ stopTest: called before afterTest(*) """ pass def handleFailure(self, test, err): ''' Called on addFailure. To handle the failure yourself and prevent normal failure processing, return a true value. ''' self.result_properties.clear() exctype, value, tb = err ctx = self.getTestCaseContext(test) #common log output grabLog(ctx.user_log_dir) shutil.move(ctx.case_report_tmp_dir, self._fail_report_path) self.result_properties.update({'extras': {'screenshot_at_failure': ctx.screenshot_at_failure, 'log': ctx.log, 'expect': ctx.expect, } }) def handleError(self, test, err): ''' Called on addError. To handle the failure yourself and prevent normal error processing, return a true value. ''' self.result_properties.clear() ctx = self.getTestCaseContext(test) #last step snapshot grabLog(ctx.user_log_dir) shutil.move(ctx.case_report_tmp_dir, self._error_report_path) self.result_properties.update({'extras': {'screenshot_at_failure': ctx.screenshot_at_failure, 'log': ctx.log, 'expect': ctx.expect, } }) def addFailure(self, test, err, capt=None, tbinfo=None): ctx = self.getTestCaseContext(test) ctx.case_end_time = reporttime() #payload data self.result_properties.update({'payload': {'tid': self.tid, 'casename': ctx.case_dir_name, 'starttime': ctx.case_start_time, 'endtime': ctx.case_end_time, 'result': 'fail', 'trace':formatOutput(ctx.case_dir_name, 'fail', err) } }) if self.opt.reportserver: self.__report_client.updateTestCase(**self.result_properties) #remote upload def addError(self, test, err, capt=None): ctx = self.getTestCaseContext(test) ctx.case_end_time = reporttime() self.result_properties.update({'payload': {'tid': self.tid, 'casename': ctx.case_dir_name, 'starttime': ctx.case_start_time, 'endtime': ctx.case_end_time, 'result': 'error', 'trace':formatOutput(ctx.case_dir_name, 'error', err) } }) if self.opt.reportserver: self.__report_client.updateTestCase(**self.result_properties) #remote upload def addSuccess(self, test, capt=None): ctx = self.getTestCaseContext(test) ctx.case_end_time = reporttime() self.result_properties.clear() self.result_properties.update({'payload': {'tid': self.tid, 'casename': ctx.case_dir_name, 'starttime': ctx.case_start_time, 'endtime': ctx.case_end_time, 'result': 'pass' } }) if self.opt.reportserver: self.__report_client.updateTestCase(**self.result_properties)
class ReporterPlugin(nose.plugins.Plugin): """ handle test output. """ name = 'reporter' #score = 200 def __init__(self, counter=None, report_client=None, timer=None): super(ReporterPlugin, self).__init__() self.__report_client = report_client if report_client else None self.__counter = counter self.__timer = timer self.__log_handler = None self.__configuration = {} def options(self, parser, env): """ Register commandline options. Called to allow plugin to register command line options with the parser. DO NOT return a value from this method unless you want to stop all other plugins from setting their options. """ super(ReporterPlugin, self).options(parser, env) ###local ouput result config### parser.add_option('--file-name', dest='file_name', default='result.txt', help="save output file to this directory") parser.add_option('--directory', action='store_true', dest='directory', default=self.__getDefault(), help="save output file to this directory. default is current nose worspace") parser.add_option('--icycle', action='store', type='string',metavar="STRING", dest='icycle', default=None, help="total cycle flag") ###report server config### parser.add_option('--reportserver', action='store_true', dest='reportserver', default=False, help="switcher of uploading result to server. default is enable the feature") parser.add_option('--server-config', action='store', metavar="FILE", dest='server_config', default='server.config', help="specify the server config file path") parser.add_option('--device-config', action='store', metavar="FILE", dest='device_config', default='device.config', help="specify the device config file path") parser.add_option('--duration', dest='duration', type='string',metavar="STRING", action='callback', callback=self.__validate_duration, help='The minumum test duration before ending the test.\ Here format must follow next format: xxDxxHxxMxxS.\ e.g. --duration=2D09H30M12S, which means 2 days, 09 hours, 30 minutes and 12 seconds') def __validate_duration(self, option, opt, value, parser): ''' ''' value = string.lower(value) begin = 0 days = hours = minutes = seconds = 0 for i, v in enumerate(value): if v == 'd': days = int(value[begin:i]) begin = i + 1 elif v == 'h': hours = int(value[begin:i]) begin = i + 1 elif v == 'm': minutes = int(value[begin:i]) begin = i + 1 elif v == 's': seconds = int(value[begin:i]) begin = i + 1 if begin == 0: parser.error('%s: duration format error' % value) times = datetime.timedelta(days=days, hours=hours, minutes=minutes, seconds=seconds) setattr(parser.values, option.dest, times) def __getDefault(self): workspace = os.getcwd() if 'WORKSPACE' in os.environ: ws = os.environ['WORKSPACE'] workspace = _mkdir(ws) return workspace def configure(self, options, conf): """ Called after the command line has been parsed, with the parsed options and the config container. Here, implement any config storage or changes to state or operation that are set by command line options. DO NOT return a value from this method unless you want to stop all other plugins from being configured. """ super(ReporterPlugin, self).configure(options, conf) if not self.enabled: return self.write_hashes = conf.verbosity == 2 self.conf = conf self.opt = options if self.opt.icycle and not self.__counter: self.__counter = TestCounter(cycles=self.opt.icycle) elif not self.__counter: self.__counter = TestCounter() if self.opt.duration and not self.__timer: self.__timer = Timer(self.opt.duration) if not self.__configuration: if self.opt.reportserver: if not exists(options.server_config): raise Exception('exit due to unable to find server configuration file: "%s"' % options.server_config) if not exists(options.device_config): raise Exception('exit due to unable to find device configuration file: "%s"' % options.device_config) self.__configuration.update(_getServerConfiguration(options.server_config)) self.__configuration.update(_getDeviceConfiguration(options.device_config)) self.__configuration.update({'planname': os.path.basename(self.conf.options.plan_file)}) self.result_properties = {'payload': None, 'extras': None} #if disable report server if self.opt.reportserver and not self.__report_client: server_need = {'username':None, 'password':None, 'auth':None, 'session_create':None, 'session_update':None, 'case_create':None, 'case_update':None, 'file_upload':None} self.__report_client = ReportClient(**self.__configuration) self.token = self.__report_client.regist() if not self.token: raise Exception('exit due to unable to get token from server!') #used to add local report if need #self.result_file = join(_mkdir(self.opt.directory), self.opt.file_name) def setOutputStream(self, stream): """ Get handle on output stream so the plugin can print id #n """ self.stream = stream def __write(self, output): ''' Write output as content ''' try: self.stream.write(output) except: pass def prepareTest(self, test): ''' enable log handler. ''' if not self.__log_handler: self.__log_handler = LogHandler(serial=self.__configuration['deviceid']) if not self.__log_handler.available(): self.__log_handler.start() def begin(self): self.session_id = self.__counter.sid self.test_start_time = getattr(self, 'test_start_time', None) if not self.test_start_time: self.test_start_time = _reportTime() self.opt.directory = self.conf.workingDir self._report_path = _mkdir(join(join(self.opt.directory, 'report'), str(self.test_start_time).replace(' ', '_'))) self._pass_report_path = _mkdir(join(self._report_path, 'pass')) self._fail_report_path = _mkdir(join(self._report_path, 'fail')) self._error_report_path = _mkdir(join(self._report_path, 'error')) self._timeout_report_path = _mkdir(join(self._report_path, 'timeout')) session_properties = {'sid': self.session_id, 'starttime': self.test_start_time } self.cid = self.__counter.next_cid() if self.write_hashes: sys.stderr.write('begin cycle: %s \n' % (self.cid)) if self.opt.reportserver and not self.__report_client.created: self.__report_client.createSession(**session_properties) def __setTestCaseContext(self, test): module_name, class_name, method_name = test.id().split('.')[-3:] ctx = TestCaseContext(self._fail_report_path, self._error_report_path) ctx.case_dir_name = '%s%s%s' % (class_name, '.', method_name) ctx.device_config = self.__configuration setattr(test.context, 'contexts', ctx) def __getTestCaseContext(self, test): return getattr(test.context, 'contexts') def prepareTestCase(self, test): self.__setTestCaseContext(test) def startTest(self, test): """ startTest: called after beforeTest(*) """ self.tid = self.__counter.next_tid() ctx = self.__getTestCaseContext(test) ctx.case_start_time = _reportTime() ctx.user_log_dir = join(ctx.case_report_tmp_dir, 'logs') path = _mkdir(ctx.user_log_dir) if self.write_hashes: self.__write('#%s %s ' % (str(self.tid), str(ctx.case_start_time))) def handleFailure(self, test, err): ''' Called on addFailure. To handle the failure yourself and prevent normal failure processing, return a true value. ''' self.result_properties.clear() exctype, value, tb = err try: ctx = self.__getTestCaseContext(test) log_file = join(ctx.user_log_dir, LOG_FILE_NAME) self.__log_handler.save(log_file) #makeLog(ctx.user_log_dir) #shutil.move(ctx.case_report_tmp_dir, self._fail_report_path) except: pass self.result_properties.update({'extras': {'screenshot_at_failure': ctx.fail_screenshot_at_failure, 'log': ctx.fail_log, 'expect': ctx.expect, } }) def handleError(self, test, err): ''' Called on addError. To handle the failure yourself and prevent normal error processing, return a true value. ''' self.result_properties.clear() try: ctx = self.__getTestCaseContext(test) log_file = join(ctx.user_log_dir, LOG_FILE_NAME) self.__log_handler.save(log_file) #makeLog(ctx.user_log_dir) except: pass self.result_properties.update({'extras': {'screenshot_at_failure': ctx.error_screenshot_at_failure, 'log': ctx.error_log, 'expect': ctx.expect, } }) def addFailure(self, test, err, capt=None, tbinfo=None): ctx = self.__getTestCaseContext(test) ctx.case_end_time = _reportTime() #payload data self.result_properties.update({'payload': {'tid': self.tid, 'casename': ctx.case_dir_name, 'starttime': ctx.case_start_time, 'endtime': ctx.case_end_time, 'result': 'fail', 'trace':_formatOutput(ctx.case_dir_name, 'fail', err) } }) trace_log_path = join(ctx.user_log_dir, 'trace.txt') with open(trace_log_path, 'w+') as f: f.write(str(self.result_properties['payload']['trace'])) _makeLog(path=ctx.user_log_dir, serial=self.__configuration['deviceid']) try: shutil.move(ctx.case_report_tmp_dir, self._fail_report_path) except: pass if self.__timer and not self.__timer.alive(): self.conf.stopOnError = True if self.opt.reportserver: self.__report_client.updateTestCase(**self.result_properties) #remote upload def addError(self, test, err, capt=None): ctx = self.__getTestCaseContext(test) ctx.case_end_time = _reportTime() self.result_properties.update({'payload': {'tid': self.tid, 'casename': ctx.case_dir_name, 'starttime': ctx.case_start_time, 'endtime': ctx.case_end_time, 'result': 'error', 'trace':_formatOutput(ctx.case_dir_name, 'error', err) } }) trace_log_path = join(ctx.user_log_dir, 'trace.txt') with open(trace_log_path, 'w+') as f: f.write(str(self.result_properties['payload']['trace'])) _makeLog(path=ctx.user_log_dir, serial=self.__configuration['deviceid']) try: shutil.move(ctx.case_report_tmp_dir, self._error_report_path) except: pass if self.__timer and not self.__timer.alive(): self.conf.stopOnError = True if self.opt.reportserver: self.__report_client.updateTestCase(**self.result_properties) #remote upload def addSuccess(self, test, capt=None): ctx = self.__getTestCaseContext(test) ctx.case_end_time = _reportTime() self.result_properties.clear() self.result_properties.update({'payload': {'tid': self.tid, 'casename': ctx.case_dir_name, 'starttime': ctx.case_start_time, 'endtime': ctx.case_end_time, 'result': 'pass' } }) #self.__log_handler.drop() log_file = join(ctx.user_log_dir, LOG_FILE_NAME) self.__log_handler.save(log_file) trace_log_path = join(ctx.user_log_dir, 'trace.txt') with open(trace_log_path, 'w+') as f: f.write(str(self.result_properties['payload']['result'])) _makeLog(path=ctx.user_log_dir, serial=self.__configuration['deviceid'], result='pass') try: shutil.move(ctx.case_report_tmp_dir, self._pass_report_path) except: pass if self.__timer and not self.__timer.alive(): self.conf.stopOnError = True if self.opt.reportserver: self.__report_client.updateTestCase(**self.result_properties) def report(self, stream): session_properties = {'sid': self.session_id} if self.opt.duration and self.__timer: session_properties.update({'status': self.__timer.progress()}) elif self.opt.icycle and self.__counter: session_properties.update({'status': self.__counter.progress()}) if self.opt.reportserver: self.__report_client.updateSession(**session_properties) return None def finalize(self, result): if self.write_hashes: self.__write('end cycle: %s \n' % (self.cid)) session_properties = {'sid': self.session_id} if self.opt.icycle and not self.__counter.alive() and self.opt.reportserver: session_properties.update({'endtime': _reportTime()}) self.__report_client.updateSession(**session_properties) if self.conf.stopOnError and self.opt.reportserver: session_properties.update({'endtime': _reportTime()}) self.__report_client.updateSession(**session_properties) sys.exit(1) return None