def run_onetime(
self,
interfacename,
casename,
config_data,
expect_data,
):
'''
path = os.path.dirname(os.getcwd())
parpath = os.path.dirname(path)
yamlname = parpath + '/Config/interface/' + '%s/%s.yaml' % (interfacename, interfacename)
config_data = Yaml.YAML().read_yaml(yamlname)'''
try:
start = time.clock()
if config_data['protocol'].lower() == 'http':
res = Http.http_runner(interfacename, casename)
end = time.clock()
Log.LOG(interfacename + '->' + casename).log_result(
'Http has get the response data using %s' %
str(end - start))
logcache = '%s--->%s: Http has get the response data using %s\n' % (
interfacename, casename, str(end - start))
(judge, error_key,
result) = self.r.assert_runner(res, expect_data)
return judge, error_key, logcache, res, round((end - start),
2), result
elif config_data['protocol'].lower() == 'https':
res = Https.https_runner(interfacename, casename)
end = time.clock()
Log.LOG(interfacename + '->' + casename).log_result(
'Https has get the response data using %s' %
str(end - start))
logcache = '%s--->%s: Http has get the response data using %s\n' % (
interfacename, casename, str(end - start))
(judge, error_key,
result) = self.r.assert_runner(res, expect_data)
return judge, error_key, logcache, res, round((end - start),
2), result
elif config_data['protocol'].lower() == 'hessian':
res = Hessian.hessian_runner(interfacename, casename)
end = time.clock()
Log.LOG(interfacename + '->' + casename).log_result(
'Hessian has get the response data using %s' %
str(end - start))
logcache = '%s--->%s: Http has get the response data using %s\n' % (
interfacename, casename, str(end - start))
(judge, error_key,
result) = self.r.assert_runnerhessian(res, expect_data)
return judge, error_key, logcache, res, round((end - start),
2), result
else:
HandleException.Exception().syntaxerror(
'The interface type is not exist! ')
except Exception, e:
HandleException.Exception().exception(e)
def all_case(self, interfacename):
try:
start = time.clock()
'''path = os.path.dirname(os.getcwd())
parpath = os.path.dirname(path)
dirname = parpath + '/TestCase/Function/' + interfacename'''
casename = HandleDB.HandleDB().db_readcase(interfacename)
end = time.clock()
Log.LOG(interfacename).log_result(
'The case of %s has built using %s' %
(interfacename, str(end - start)))
Log.LOG(interfacename).log_result('The caselist is:\n %s' %
str(casename))
return casename
except Exception, e:
HandleException.Exception().exception(
'all_case raise exception:\n' + e)
def http_req(self):
# 不同method请求发送,返回请求结果集
try:
if self.method.lower() == 'get':
r = requests.Session()
r.keep_alive = False
self.req = r.get(url=self.host, params=self.params, headers=self.headers, data=self.data, cookies=self.cookie)
r.close()
self.req.close()
return self.req
elif self.method.lower() == 'post':
r = requests.Session()
r.keep_alive = False
self.req = r.post(url=self.host, params=self.params, headers=self.headers, data=self.data, cookies=self.cookie)
r.close()
self.req.close()
return self.req
elif self.method.lower() == 'put':
r = requests.Session()
r.keep_alive = False
self.req = r.put(url=self.host, params=self.params, headers=self.headers, data=self.data, cookies=self.cookie)
r.close()
self.req.close()
return self.req
elif self.method.lower() == 'patch':
r = requests.Session()
r.keep_alive = False
self.req = r.patch(url=self.host, params=self.params, headers=self.headers, data=self.data,
cookies=self.cookie)
r.close()
self.req.close()
return self.req
elif self.method.lower() == 'delete':
r = requests.Session()
r.keep_alive = False
self.req = r.delete(url=self.host, params=self.params, headers=self.headers, data=self.data,
cookies=self.cookie)
r.close()
self.req.close()
return self.req
else:
Log.LOG(self.host).log_info('The method of Http Request is invalid!')
return None
except Exception, e:
Log.LOG(self.host).log_error(e)
def print_responsedata(self):
s = '----------------response start----------------'
s = s + '\n' + 'The data of response:' + '\n' + 'The return status:' + str(self.result['req_status'])
s = s + '\n' + 'The return headers:' + str(self.result['req_headers'])
s = s + '\n' + 'The return content:' + str(self.result['req_content'])
s = s + '\n' + 'The return cookies: ' + str(self.result['req_cookie'])
s = s + '\n' + 'The return token: ' + str(self.result['req_token'])
s = s + '\n' + '----------------response end----------------'
Log.LOG().log_info(s)
def print_inputdata(self, inputdata, http_data, interfacename, casename):
# 打印入参数据
s = '\n' + '----------------http request start----------------' + '\n' + 'The request host:' + str(inputdata['host'])
s = s + '\n' + 'The request headers:' + str(inputdata['headers'])
if http_data['data'] != None:
s = s + '\n' + 'The request body:' + str(inputdata['data'])
s = s + '\n' + 'The request params:' + str(inputdata['params'])
s = s + '\n' + 'The request method:' + str(inputdata['method'])
s = s + '\n' + 'The request cookie:' + str(inputdata['cookie'])
s = s + '\n' + '----------------request end----------------'
Log.LOG(interfacename + '->' + casename + '-->' + inputdata['host']).log_info(s)
def read_inputdata(self, interfacename, casename):
try:
path = os.path.dirname(os.getcwd())
parpath = os.path.dirname(path)
# 获取接口配置数据
config_data = self.get_configdata(interfacename)
case_data = config_data
# 从case中取参数
'''filename = parpath + '/TestCase/Function/' + '%s/%s.txt' % (interfacename, casename)
with open(filename, 'r')as f:
para_data = f.read()
# 对case里取出的string流处理
para_data = TransCode.TransCode().transcode(para_data)'''
para_data = HandleDB.HandleDB().db_readcaseinfo(casename)
Log.LOG(interfacename + '--->' + casename).log_result('para_data: %s\n'%para_data)
case_data['params'] = para_data
return case_data
except Exception,e:
HandleException.Exception().exception('read_inputdata raise exception:\n'+ e)
def systemerror(self, s):
try:
raise SystemError
except SystemError:
Log.LOG('System Error').log_error(s)
def syntaxerror(self, s):
try:
raise SyntaxError
except SyntaxError:
Log.LOG('Syntax Error').log_error(s)
def exception(self, e):
# 打印代码内部错误
Log.LOG('Program error').log_error(e)
def transcode(self, strobject):
result = chardet.detect(strobject)
coding = result.get('encoding')
Log.LOG('case coding type').log_result(coding)
new = strobject.decode('GBK').encode('UTF-8')
return new
def run_singleinterface(self, interfacename, taskid):
# 建立case
path = os.path.dirname(os.getcwd())
parpath = os.path.dirname(path)
start = time.clock()
# 取配置值
config_data = InputData.INPUTDATA().get_configdata(interfacename)
jarname = config_data['jarname']
classname = config_data['classname']
funcname = config_data['funcname']
projectname = config_data['projectname']
ruler_data = Ruler.RULER().ruler_data(interfacename)
Log.LOG(interfacename).log_result('The config data of %s:\n%s' %
(interfacename, str(config_data)))
# 取期望值
expect_data = HandleDB.HandleDB().db_readexpect(interfacename)
case_error = self.build_case(interfacename, expect_data, ruler_data,
jarname, classname, funcname)
Log.LOG(interfacename).log_result('The case of %s build success...' %
interfacename)
casename = self.all_case(interfacename)
print type(casename)
report_case = {}
# 如果不是无参接口
if ruler_data != None and isinstance(casename, list):
for i in range(len(casename)):
starttime = time.strftime("%Y-%m-%d %H:%M:%S",
time.localtime())
try:
(judge, error_key, runtimes, logcache2, res, usetime,
result) = self.run_singlecase(interfacename, casename[i],
config_data, expect_data,
projectname)
realvalue = str(res).replace("'", "\"")
# realvalue = json.dumps(realvalue, ensure_ascii=False)
# print realvalue, type(realvalue)
error_key = json.dumps(error_key, ensure_ascii=False)
logcache = str(logcache2).replace("'", "\"")
# 处理res 写进response表
content_type = str(res['req_headers']['Content-Type'])
for k in res:
if k == 'req_headers':
res[k] = str(res[k]).replace("'", "\"")
except Exception, e:
res = {
"req_status": 999,
"req_headers": None,
"req_content": None,
"req_token": None,
"req_cookie": None
}
HandleException.Exception().exception(
str(casename[i]) + 'raise exception:\n' + e)
judge = {
"body": None,
"headers": None,
"schema": None,
"content_type": None,
"status_code": None
}
error_key = None
runtimes = 0
logcache = None
realvalue = None
result = 'Not Run'
content_type = None
usetime = 'Unknown'
iserror = case_error[casename[i]]
endtime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
resultid = HandleDB.HandleDB().db_writeresult(
taskid, interfacename, jarname, classname,
funcname, casename[i], result, realvalue, error_key,
str(runtimes - 1), iserror, judge, starttime, endtime,
usetime)
HandleDB.HandleDB().db_writecaselog(casename[i], logcache,
interfacename, resultid)
HandleDB.HandleDB().db_writeresponse(resultid, res,
content_type)
report_case[casename[i]] = {
'result': result,
'judge': judge,
'usetime': usetime
}
def run_singlecase(self, interfacename, casename, config_data, expect_data,
projectname):
try:
# 测试前数据库操作
sql = config_data['sql_pre']
finish = self.sql_preoperation(sql)
env = HandleDB.HandleDB().db_readenvirement(projectname)
retry = env['isRetry']
wholetime = 0.00
if finish != 1:
runtime = env['retrytimes']
judge = False
error_key = 'Pre Sql Operation cannot pass !'
res_data = ''
logcache2 = '%s--->%s: %s' % (interfacename, casename,
error_key)
else:
runtime = 0
logcache2 = ''
while runtime < env['retrytimes'] and retry == True:
(judge, error_key, logcache, res, usetime,
result) = self.run_onetime(interfacename, casename,
config_data, expect_data)
wholetime += usetime
if judge != True:
Log.LOG(interfacename + '->' + casename).log_result(
'Run fail %d times,The error: \n %s' %
(runtime + 1, str(error_key)))
logcache = logcache + '%s-->%s: Run fail %d times,The error: \n %s' % (
interfacename, casename, runtime + 1,
str(error_key)) + '\n'
else:
Log.LOG(interfacename + '->' +
casename).log_result('Run success')
Log.LOG(interfacename + '->' + casename).log_result(
'The check data: \n %s' % res_data)
logcache = logcache + '%s-->%s: Run success\n The check data: \n %s' % (
interfacename, casename, res_data) + '\n'
# 若通过不再重跑
runtime = env['retrytimes']
logcache2 += logcache
runtime += 1
if retry != True:
(judge, error_key, logcache, res, usetime,
result) = self.run_onetime(interfacename, casename,
config_data, expect_data)
wholetime += usetime
if judge != True:
Log.LOG(interfacename + '->' + casename).log_result(
'Run fail %d times,The error: \n %s' %
(runtime + 1, str(error_key)))
logcache = logcache + '%s-->%s: Run fail %d times,The error: \n %s' % (
interfacename, casename, runtime + 1,
str(error_key)) + '\n'
else:
Log.LOG(interfacename + '->' +
casename).log_result('Run success')
Log.LOG(interfacename + '->' + casename).log_result(
'The check data: \n %s' % res_data)
logcache = logcache + '%s-->%s: Run success\n The check data: \n %s' % (
interfacename, casename, res_data) + '\n'
logcache2 += logcache
runtime += 1
return judge, error_key, runtime, logcache2, res, wholetime, result
except Exception, e:
HandleException.Exception().exception(e)
'judge': judge,
'usetime': usetime
}
# testsuite.addTest(Html.ParametrizedTestCase.parametrize(Html.TestOne, param=judge))
# BuildHtml.BuildHtml().build_funcreport(interfacename, report_case, expect_data)
# 将每个case加载到报告中
# Html.BuildHtmlReport().gen_htmlreport(interfacename, testsuite)
end = time.clock()
# 数据库收尾处理
sql = config_data['sql_after']
if sql != None:
finish = HandleDB.HandleDB().db_generaloperation(sql)
else:
finish = 1
if finish == 1:
Log.LOG(interfacename).log_result(
'The %s end running------------------' % interfacename)
Log.LOG(interfacename).log_result(
'The whole time of running %s is %s' %
(interfacename, str(end - start)))
else:
Log.LOG(interfacename).log_result(
'The after sql operation is unfinished!')
def run_task(self, taskid):
# 读取interfacelist
(interfacelist, projectname) = HandleDB.HandleDB().db_readtask(taskid)
if interfacelist == None:
emailcontent = 'The task set is None ,can not run!'
else:
for i in range(len(interfacelist)):
self.run_singleinterface(interfacelist[i], taskid)
