def main():
# 连接数据库，获取连接实例对象
db = DB()
# 从数据库中获取需要执行的api集合
api_list = db.get_api_list()
for id, api in enumerate(api_list,1): #下标从1开始
api_id = api[0]
api_name = api[1]
req_url = api[2]
req_method = api[3]
parm_type = api[4]
# print(api_id,api_name,req_url,req_method,parm_type)
# 通过api_id获取它对应的测试用例
api_case_list = db.get_api_case_list(api_id)
for idx,case in enumerate(api_case_list,1):
case_id = case[0]
request_data = eval(case[2]) if case[2] else {} # str转为dict为后续转json使用
rely_data = case[3]
protocol_code = case[4]
data_store = eval(case[6]) if case[6] else {}
check_point = eval(case[7]) if case[7] else {}
# print(case_id,request_data,rely_data,protocol_code,data_store,check_point)
info("第[%s]个接口,接口名是[%s],请求url是[%s],请求方式是[%s],参数类型是[%s]" % (id, api_name, req_url, req_method, parm_type))
info("接口[%s]的第[%s]条用例,请求参数是%s, 依赖数据是%s" %(api_name,idx,request_data,rely_data))
# 接下来进行数据依赖的处理
if rely_data:
request_data = GetRely.get(request_data,eval(rely_data))
info("接口[%s]的第[%s]条用例,依赖数据处理后的请求参数是%s" % (api_name, idx, request_data))
else:
info("接口[%s]的第[%s]条用例不需要处理依赖数据!" % (api_name,idx))
#接下来进行接口请求，并获取响应body
hc = HttpClient()
responseObj = hc.request(req_url,req_method,parm_type,request_data)
# 接下来进行数据依赖存储
code = responseObj.status_code
info("接口[%s]的第[%s]条用例,实际响应结果是%s" %(api_name,idx,responseObj.json()))
if code == int(protocol_code):
# 进行数据依赖存储
if data_store:
RelyDataStore.do(data_store,api_name,case_id,request_data,responseObj.json())
info("接口[%s]的第[%s]条用例的依赖数据存储成功！" %(api_name,idx))
else:
info("接口[%s]的第[%s]条用例的不需要依赖数据存储！" %(api_name,idx))
# 接下来进行结果校验
error_info = CheckResult.check(responseObj.json(),check_point)
if error_info:
debug("接口[%s]的第[%s]条用例校验结果失败，错误信息：%s" % (api_name,idx,error_info))
else:
info("接口[%s]的第[%s]条用例运行成功!" %(api_name,idx))
else:
debug("接口[%s]的第[%s]条用例响应协议code=%s，不是期望值code=%s!" %(api_name,idx,code,protocol_code))
def run(self):
if self.pidfile:
with open(self.pidfile, 'w') as pidfile:
pidfile.write(str(os.getpid()) + "\n")
json_data = {'lastid': 0, 'limit': 10}
try:
httpc = HttpClient()
response = httpc.post_json_with_secret(self.endpoint,
self.shared_secret,
json_data)
print response.body
except urllib2.HTTPError, e:
print e.args
def main():
# 连接数据库，获取连接实例对象
db = DB()
# 从数据库中获取需要执行的api集合
api_list = db.get_api_list()
for id, api in enumerate(api_list, 1):
api_id = api[0]
api_name = api[1]
req_url = api[2]
req_method = api[3]
parm_type = api[4]
# 通过api_id获取它对应的测试用例
api_case_list = db.get_api_case(api_id)
for idx, case in enumerate(api_case_list, 1):
case_id = case[0]
request_data = eval(case[2]) if case[2] else {}
rely_data = case[3]
protocol_code = case[4]
data_store = eval(case[6]) if case[6] else {}
check_point = eval(case[7]) if case[7] else {}
# 接下来进行数据依赖的处理
if rely_data:
rely_data = eval(rely_data)
request_data = GetRely.get(request_data, rely_data)
else:
info("接口[%s]的第%s用例不需要依赖数据!" % (api_name, idx))
# 接下来进行接口请求，并获取响应body
hc = HttpClient()
responseObj = hc.request(req_url, req_method, parm_type,
request_data)
code = responseObj.status_code
info("接口[%s]的第%s用例的实际响应结果为:%s" %
(api_name, idx, responseObj.json()))
if code == int(protocol_code):
# 进行数据依赖存储
RelyDataStore.do(data_store, api_name, case_id, request_data,
responseObj.json())
info("接口[%s]的第%s用例的依赖数据存储成功！" % (api_name, idx))
# 接下来进行结果校验
error_info = CheckResult.check(responseObj.json(), check_point)
if error_info:
debug("接口[%s]的第%s用例校验结果失败，错误信息：%s" %
(api_name, idx, error_info))
else:
info("接口[%s]的第%s用例运行成功！" % (api_name, idx))
else:
info("接口[%s]的第%s用例响应协议code=%s，不是期望值code=%s" %
(api_name, idx, code, protocol_code))
def main():
db = DB()
apiList = db.get_api_list()
print(apiList)
for api in apiList:
api_case_list = db.get_api_case(api[0])
print(api_case_list)
for case in api_case_list:
rely_lsit = case[3]
print(type(rely_lsit))
request_data = eval(case[2])
# 接下来进行数据依赖处理
if rely_lsit:
rely_lsit = eval(rely_lsit)
rely_case_id = rely_lsit[0].split(".")[2]
request_data = get_rely_data(rely_case_id, rely_lsit,
request_data)
# 特殊处理一下密码加密
if api[2] == "users_login":
request_data["password"] = md5_encrypt(
request_data["password"])
# 接下来进行接口请求，并获取响应body
responseObj = HttpClient.request(api[3], api[4], api[5],
request_data)
print(responseObj.status_code)
# 接下来进行数据依赖存储
if responseObj.status_code == 200 and responseObj.json(
)["code"] == "00" and case[6]:
rely_data_store(api[0], case[0], api[1], eval(case[6]),
request_data, responseObj.json())
# 接下来进行接口响应结果验证
errorInfo = CheckResult.check(responseObj.json(), eval(case[7]))
print(errorInfo)
db.write_check_result(case[0], errorInfo, request_data)
def get_pre_login_status(username_):
"""
Perform pre login action, get pre login status, including server time, nonce, rsa kv, etc.
"""
pre_login_url_ = PRE_LOGIN_URL % get_user(username_)
data_ = StringUtils.convert_to_str(HttpClient.get(pre_login_url_))
p_ = re.compile('\((.*)\)')
json_data = p_.search(data_).group(1)
data_ = json.loads(json_data)
server_time_ = str(data_['servertime'])
nonce_ = data_['nonce']
rsa_kv_ = data_['rsakv']
return server_time_, nonce_, rsa_kv_
def main():
# 新建一个解析excel工具类的实例对象
parseE = ParseExcel()
parseE.loadWorkBook(FILEPATH)
sheetObj = parseE.getSheetByName("API")
# 获取active列的列对象
activeList = parseE.getColumn(sheetObj, API_active)
for idx, cell in enumerate(activeList[1:], 2):
if cell.value == "y":
# 需要执行的接口所在行的行对象
rowObj = parseE.getRow(sheetObj, idx)
apiName = rowObj[API_apiName - 1].value
requestUrl = rowObj[API_requestUrl - 1].value
requestMethed = rowObj[API_requestMethod - 1].value
paramsType = rowObj[API_paramsType - 1].value
apiTestCaseFileName = rowObj[API_apiTestCaseFileName - 1].value
# 下一步需要读取接口用例表，获取接口的测试用例
caseSheelObj = parseE.getSheetByName(apiTestCaseFileName) # obj数据类型
caseActiveObj = parseE.getColumn(caseSheelObj, CASE_active) # tuple 数据类型
for c_idx, c_cell in enumerate(caseActiveObj[1:], 2):
if c_cell.value == "y":
# 说明此case行需要被执行
caseRowObj = parseE.getRow(caseSheelObj, c_idx)
requestData = caseRowObj[CASE_requestData - 1].value
requestData = eval(requestData) if requestData else {}
relyData = caseRowObj[CASE_relyData - 1].value
responseCode = caseRowObj[CASE_responseCode - 1].value
dataStore = caseRowObj[CASE_dataStore - 1].value
checkPoint = caseRowObj[CASE_checkPoint - 1].value
# 接口发送请求之前需要先做依赖数据的处理
if relyData:
requestData = GetRely.get(requestData, eval(relyData))
# 构造接口请求需要的数据
httpC = HttpClient()
response = httpC.request(requestUrl, requestMethed, paramsType, requestData)
http_code = response.status_code
#print(response.status_code)
print("response.json: ",response.json())
if http_code == responseCode:
if dataStore:
RelyDataStore.do(eval(dataStore), apiName, c_idx - 1, requestData, response.json())
else:
print("第%s个接口的第%s条用例不需要依赖数据存储！")
else:
print("第%s个接口的第%s条用例的协议code码【%s】不符合预期值【%s】" % (idx - 1, c_idx - 1, http_code, responseCode))
#下面进行校验点检测功能的实现
if checkPoint:
errorInfo = CheckResult.check(response.json(),eval(checkPoint))
#print("errorInfo: ",errorInfo)
write_result(parseE,caseSheelObj,response.json(),errorInfo,c_idx)
else:
print("第%s个接口的第%s条用例没有设置校验点！"%(idx - 1, c_idx - 1))
else:
print("第%s个接口的第%s条用例被忽略执行！" %(idx - 1, c_idx - 1))
else:
print("第%s个接口被设置忽略执行！" %(idx - 1))
def main():
# 新建一个解析excel工具类的实例对象
parseE = ParseExcel()
parseE.loadWorkBook(FILEPATH)
sheetObj = parseE.getSheetByName("API")
#print(sheetObj)
# 获取active列的列对象
activeList = parseE.getColumn(sheetObj, API_active)
#下面第一层遍历是为了读取excel主表api信息，读取测试用例
for idx, cell in enumerate(activeList[1:], 2):
if cell.value == "y":
# 需要执行的接口所在的行的对象
rowObj = parseE.getRow(sheetObj, idx)
apiName = rowObj[API_apiName - 1].value
requestUrl = rowObj[API_requestUrl - 1].value
requestMethed = rowObj[API_requestMothod - 1].value
paramsType = rowObj[API_paramsType - 1].value
apiTestCaseFileName = rowObj[API_apiTestCaseFileName - 1].value
# 下一步需要读取接口用例表，获取接口的测试用例
caseSheetObj = parseE.getSheetByName(apiTestCaseFileName) # obj类型
caseActiveObj = parseE.getColumn(caseSheetObj, CASE_active) # tuple类型
print(caseActiveObj)
#第二层for循环是读取每个测试用例（注册接口用例，登录接口用例， 查询博文用例）里面的信息
for c_idx, c_cell in enumerate(caseActiveObj[1:], 2):
if c_cell.value == "y":
# 说明此case需要被执行
caseRowObj = parseE.getRow(caseSheetObj, c_idx)
requestData = caseRowObj[CASE_requestData - 1].value
requestData = eval(requestData) if requestData else {}
relyData = caseRowObj[CASE_relyData - 1].value
responseCode = caseRowObj[CASE_responseCode - 1].value
dataStore = caseRowObj[CASE_dataStore - 1].value
checkPoint = caseRowObj[CASE_checkPoint - 1].value
print(requestData, relyData, responseCode, dataStore, checkPoint)
#接口发送请求之前需要先做数据依赖处理
if relyData:
requestData = GetRely.get(requestData,eval(relyData))
#构造接口欧请求需要的数据，并调用HttpClient类中的方法发送接口，获取响应结果
hc = HttpClient()
response= hc.request(requestUrl,requestMethed,paramsType,requestData)
if response.status_code == responseCode:
responseBody = response.json()
#print(responseBody)
#获取到接口响应的body后，接下来处理依赖数据的存储
if dataStore:
RelyDataStore.do(eval(dataStore),apiName,c_idx-1,requestData,responseBody)
else:
print("第%s个接口的第%s条用例不需要存储数据依赖" %(idx - 1, c_idx - 1))
#接下来进行接口响应结果的校验
if checkPoint:
errorInfo = CheckResult.Check(responseBody,eval(checkPoint))
WriteTestResult.write(parseE,caseSheetObj,responseBody,errorInfo,c_idx)
# if errorInfo:
# print("第%s个接口的第%s条校验失败，错误与信息：%s" %(idx - 1, c_idx - 1,errorInfo))
else:
print("第%s个接口的第%s条用例未设置校验点" %(idx - 1, c_idx - 1))
else:
print("第%s个接口的第%s条用例所调用的接口响应失败，响应code=%s,而预期响应code=%s" %(idx - 1, c_idx - 1,response.status_code,\
responseCode))
else:
print("第%s个接口的第%s条用例被忽略执行！" %(idx - 1, c_idx - 1))
else:
print("第%s个接口被设置忽略执行！" %(idx - 1))
def run_test():
# 解析测试数据excel表
pe = ParseExcel()
pe.loadWorkBook(r'%s' % test_data_file_path)
# 获取接口表数据
apisheet_obj = pe.getSheetByName('API')
# 获取是否执行列
apisheet_isExecute = pe.getCol(apisheet_obj, API_isExecute)
# print(apisheet_isExecute)
# 统计总数
execute_case_no = 0
faild_case_no = 0
success_case_no = 0
# 生成报告数据
test_results_for_html_report = []
# info("-----------------执行api--------------------")
for idx, cell in enumerate(apisheet_isExecute[1:],
2): # 从第2行开始，遍历要是否执行列，设置idx从2开始
# 接口需要执行的接口
if cell.value and cell.value.strip().lower() == 'y':
# 需要执行的接口所在的行对象
apisheet_rowObj = pe.getRow(apisheet_obj, idx)
# api名称
apisheet_apiName = apisheet_rowObj[API_apiName - 1].value
apisheet_requestPath = apisheet_rowObj[API_requestPath - 1].value
apisheet_requestMethod = apisheet_rowObj[API_requestMethod -
1].value
apisheet_paramsType = apisheet_rowObj[API_paramsType - 1].value
apisheet_headers = apisheet_rowObj[API_headers - 1].value
apisheet_cookies = apisheet_rowObj[API_cookies - 1].value
info("---------------执行api：%s------------------" %
apisheet_apiName)
# 测试用例表名
apisheet_caseSheetName = apisheet_rowObj[API_caseSheetName -
1].value
# 处理api请求url
apisheet_requestUrl = get_url(apisheet_requestPath)
# 统计每个api的执行结果
api_case_no = 0
api_case_success_no = 0
api_case_fail_no = 0
info("------------------执行用例：%s-----------------" %
apisheet_caseSheetName)
# 获取测试用例表对象
casesheet_obj = pe.getSheetByName(apisheet_caseSheetName)
# 获取是否需要执行的用例列对象
casesheet_isExecute = pe.getCol(casesheet_obj, CASE_isExecute)
for c_idx, c_cell in enumerate(casesheet_isExecute[1:], 2):
# 用例是否执行
if c_cell.value and c_cell.value.strip().lower() == 'y':
execute_case_no += 1
api_case_no += 1
# 获取要执行的用例表的行对象
casesheet_rowObj = pe.getRow(casesheet_obj, c_idx)
casesheet_caseName = casesheet_rowObj[CASE_caseName -
1].value
casesheet_requestData = casesheet_rowObj[CASE_requestData -
1].value
# 依赖字段
casesheet_dependApiNoCaseNo = casesheet_rowObj[
CASE_dependApiNoCaseNo - 1].value
casesheet_dependRequestDataFields = casesheet_rowObj[
CASE_dependRequestDataFields - 1].value
casesheet_dependResponseDataFields = casesheet_rowObj[
CASE_dependResponseDataFields - 1].value
casesheet_dependStoreRequestDataFields = casesheet_rowObj[
CASE_dependStoreRequestDataFields - 1].value
casesheet_dependStoreResponseDataFields = casesheet_rowObj[
CASE_dependStoreResponseDataFields - 1].value
casesheet_storeDataFields = casesheet_rowObj[
CASE_storeDataFields - 1].value
casesheet_assertData = casesheet_rowObj[CASE_assertData -
1].value
# info("----------------------请求前数据处理-----------------------")
# 处理url中的参数
if '{' in apisheet_requestUrl:
apisheet_requestUrl = handle_url_params(
apisheet_requestUrl, eval(casesheet_requestData))
# 获取headers
if apisheet_headers and apisheet_headers.strip().lower(
) == 'y':
apisheet_headers = get_headers()
# 获取cookies
if apisheet_cookies and apisheet_cookies.strip().lower(
) == 'y':
apisheet_cookies = get_cookies()
# 处理唯一数
if "${unique" in casesheet_requestData:
casesheet_requestData = handle_unique_num(
casesheet_requestData)
# 处理加密数据
if "${encrypt" in casesheet_requestData:
casesheet_requestData = handler_encrypt(
casesheet_requestData)
# 处理依赖数据
if casesheet_dependApiNoCaseNo:
casesheet_requestData = get_request_data(
pe, apisheet_obj, casesheet_dependApiNoCaseNo,
casesheet_requestData,
casesheet_dependRequestDataFields,
casesheet_dependResponseDataFields,
casesheet_dependStoreRequestDataFields,
casesheet_dependStoreResponseDataFields)
if not isinstance(casesheet_requestData, dict):
casesheet_requestData = eval(casesheet_requestData)
info("----------------------发送请求-----------------------")
info("请求 url：%s" % apisheet_requestUrl)
info("请求 方法：%s" % apisheet_requestMethod)
info("请求参数类型：%s" % apisheet_paramsType)
info("请求数据：%s" % casesheet_requestData)
info("请求头数据：%s" % apisheet_headers)
info("请求cookies数据：%s" % apisheet_cookies)
httpc = HttpClient()
# 请求计时开始
start_time = time.time()
# 发送请求
response = httpc.request(
requestUrl=apisheet_requestUrl,
requestMethod=apisheet_requestMethod,
paramsType=apisheet_paramsType,
requestData=casesheet_requestData,
headers=apisheet_headers,
cookies=apisheet_cookies)
# 耗时
escape_time = time.time() - start_time
info("响应结果：%s" % response)
# 请求成功
if response.status_code == 200:
info("------------------处理响应数据-------------------")
# 响应数据
casesheet_responseData = response.json()
response_content = response.content.decode('utf-8')
info("响应数据：%s" % response.content.decode('utf-8'))
# 存储依赖数据
if casesheet_storeDataFields:
store_result = store_data(
pe, casesheet_obj, c_idx,
eval(casesheet_storeDataFields),
casesheet_requestData, response)
info("存储依赖数据执行结果：%s" % store_result)
# 比对结果
error_key = {}
if casesheet_assertData:
error_key = assert_result(
casesheet_responseData,
eval(casesheet_assertData))
info("断言结果error_key：%s" % error_key)
if error_key:
faild_case_no += 1
api_case_fail_no += 1
test_results_for_html_report.append(
(apisheet_requestUrl, casesheet_requestData,
response_content, int(escape_time * 1000),
casesheet_assertData, "失败"))
else:
success_case_no += 1
api_case_success_no += 1
test_results_for_html_report.append(
(apisheet_requestUrl, casesheet_requestData,
response_content, int(escape_time * 1000),
casesheet_assertData, "成功"))
# 写测试结果
write_result(pe, casesheet_obj, casesheet_responseData,
error_key, c_idx, escape_time)
else:
info('响应失败，响应状态码：%s' % response.status_code)
clear_result(pe, casesheet_obj, row_no=c_idx)
else:
clear_result(pe, casesheet_obj, row_no=c_idx)
info('case：%s 被忽略执行' % casesheet_caseName)
# 写接口的执行结果
write_api_result(pe, apisheet_obj, idx, api_case_no,
api_case_success_no, api_case_fail_no)
else:
#清空忽略执行的接口结果
clear_api_result(pe, apisheet_obj, idx)
info('api：%s 被忽略执行' % apisheet_apiName)
# 写报告
info("-------------------生成报告--------------------")
report_name = get_report_name()
report_html(data=test_results_for_html_report, html_name=report_name)
time.sleep(3)
# 发送邮件
info("-------------------发送邮件--------------------")
send_file = report_name + '.html'
send_content="本次自动化测试共执行用例数：%s，成功数：%s，失败数：%s,成功率：%.2f%%"\
%(execute_case_no,success_case_no,faild_case_no,success_case_no/execute_case_no*100)
send_mail(send_file, send_content)
def main():
#file_path=r"D:\20170721exercise\interfaceFrame201807\TestData\inter_test_data.xlsx"
parseE = ParseExcel()
parseE.loadWorkBook(file_path)
sheetObj = parseE.getSheetByName(u"API")
#print sheetObj
activeList = parseE.getColumn(sheetObj, 7)
#print activeList
#for i in activeList:
#print i.value
#外层for循环，遍历的api的sheet表
for idx, cell in enumerate(activeList[1:],2):
#print idx
if cell.value == "y":
# 需要执行的接口所在行的行对象
rowObj = parseE.getRow(sheetObj, idx)
#print type(rowObj)
apiName = rowObj[API_apiName-1].value
requestUrl = rowObj[API_requestUrl-1].value
requestMethod = rowObj[API_requestMothod-1].value
paramsType = rowObj[API_paramsType-1].value
apiTestCaseFileName = rowObj[API_apiTestCaseFileName-1].value
#print apiName, requestUrl, requestMothod, paramsType, apiTestCaseFileName
# 下一步读用例sheet表，准备执行测试用例
caseSheetObj = parseE.getSheetByName(apiTestCaseFileName)
caseActiveObj = parseE.getColumn(caseSheetObj, CASE_active)
# for i in caseActiveObj:
# print i.value
#内层for循环，遍历的测试用例的sheet
for c_idx, col in enumerate(caseActiveObj[1:], 2):
if col.value == "y":
# 说明此case行需要执行
caseRowObj = parseE.getRow(caseSheetObj, c_idx)
requestData = caseRowObj[CASE_requestData - 1].value
relyData = caseRowObj[CASE_relyData - 1].value
# print requestData
# print relyData
dataStore=caseRowObj[CASE_dataStore-1].value
checkPoint=caseRowObj[CASE_checkPoint-1].value
if relyData:
#发送接口请求之前，先做依赖数据的处理
requestData = "%s" %GetKey.get(eval(requestData),eval(relyData))
#print type(requestData)
#print requestData
# 拼接接口请求参数，发送接口请求
#print type(requestData)
httpC = HttpClient()
#print requestMethod, requestUrl, paramsType, requestData
response = httpC.request(requestMethod=requestMethod,requestUrl=requestUrl,paramsType=paramsType,requestData=requestData)
if response.status_code==200:
responseData = response.json()
#存储依赖数据
if dataStore:
RelyDataStore.do(eval(dataStore),apiName,c_idx-1,eval(requestData),responseData)
#比对结果
errorKey = CheckResult.check(responseData,eval(checkPoint))
write_result(parseE,caseSheetObj,responseData,errorKey,c_idx)
# if not errorKey:
# print "校验结果通过"
# else:
# print "校验失败",errorKey
else:
print response.status_code
else:
print "用例被忽略执行"
else:
print "接口被设置忽略执行"
def init_http_client():
# 初始化HttpClient，即全局urllib2
HttpClient.create_http_client(user_agent=Configuration.USER_AGENT, cookie_file=COOKIE_FILE, init_cookie=Login.do_login)
def main(): parseE = ParseExcel() parseE.loadWorkBook(file_path) sheetObj = parseE.getSheetByName(u"API") activeList = parseE.getColumn(sheetObj, API_active) print activeList for idx, cell in enumerate(activeList[1:], 2): if cell.value == "y": # 需要执行的接口所在行的行对象 rowObj = parseE.getRow(sheetObj, idx) apiName = rowObj[API_apiName - 1].value requestUrl = rowObj[API_requestUrl - 1].value requestMethod = rowObj[API_requestMothod - 1].value paramsType = rowObj[API_paramsType - 1].value apiTestCaseFileName = rowObj[API_apiTestCaseFileName - 1].value # 下一步读用例sheet表，准备执行测试用例 caseSheetObj = parseE.getSheetByName(apiTestCaseFileName) caseActiveObj = parseE.getColumn(caseSheetObj, CASE_active) for c_idx, col in enumerate(caseActiveObj[1:], 2): if col.value == "y": # 说明此case行需要执行 caseRowObj = parseE.getRow(caseSheetObj, c_idx) requestData = caseRowObj[CASE_requestData - 1].value relyData = caseRowObj[CASE_relyData - 1].value dataStore = caseRowObj[CASE_dataStore - 1].value checkPoint = caseRowObj[CASE_checkPoint - 1].value headers = caseRowObj[CASE_headers - 1].value print headers if relyData: # 发送接口请求之前，先做依赖数据的处理 requestData = "%s" %GetKey.get(eval(requestData), eval(relyData)) # 拼接接口请求参数，发送接口请求 httpC = HttpClient() # print requestMethod, requestUrl, paramsType, requestData response = httpC.request(requestMethod = requestMethod, requestUrl = requestUrl, paramsType = paramsType, requestData = requestData, headers=headers ) print response.text if response.status_code == 200: responseData = response.json()#对比json responseText = response.text # 存储依赖数据 if dataStore: RelyDataStore.do(eval(dataStore),apiName, c_idx - 1, eval(requestData),responseData) # 比对结果 errorKey = CheckResult.check(responseData, eval(checkPoint)) print type(responseData) write_result(parseE, caseSheetObj,responseText, errorKey, c_idx)#讲返回的报文体填入结果 else: responseData = response.json() responseText = response.text print "错误json%s"%responseData errorKey = CheckResult.check(responseData, eval(checkPoint)) print responseData,type(eval(checkPoint)) write_result(parseE, caseSheetObj, responseText,errorKey,c_idx) print errorKey print responseData else: print "用例被忽略执行" else: print "接口被设置忽略执行"
def main():
# 实现从获取接口测试数据到发送情况，再到获取返回结果，并处理结果
# 创建ParseExcel类的实例对象
parseE = ParseExcel()
# 调用封装好的加载excel到内存的方法将需要解析的excel加载到内存
parseE.loadWorkBook(excelPath)
# 获取“API”表的表对象
sheetObj = parseE.getSheetByName(apiExcelName)
# 获取API表中是否需要执行api自动化case的列对象
activeList = parseE.getColumn(sheetObj, API_active)
# 遍历是否需要执行标记列，只执行标记为yes的api自动化测试
for idx, cell in enumerate(activeList[1:], 2):
if cell.value == "y":
# 需要执行的api
rowObj = parseE.getRow(sheetObj, idx)
apiName = rowObj[API_apiName -1].value
requestUrl = rowObj[API_requestUrl - 1].value
requestMethod = rowObj[API_requestMothod - 1].value
paramsType = rowObj[API_paramsType - 1].value
apiTestCaseSheetName = rowObj[API_apiTestCaseFileName -1].value
# 下一步就是获取api的测试case，然后准备执行用例
caseSheetObj = parseE.getSheetByName(apiTestCaseSheetName)
caseActiveObj = parseE.getColumn(caseSheetObj, CASE_active)
print(caseActiveObj)
for c_idx, col in enumerate(caseActiveObj[1:], 2):
if col.value == "y":
# 说明当前case是需要被执行的
caseRowObj = parseE.getRow(caseSheetObj, c_idx)
requestData = caseRowObj[CASE_requestData - 1].value
relyData = caseRowObj[CASE_relyData - 1].value
dataStore = caseRowObj[CASE_dataStore - 1].value
checkPoint = caseRowObj[CASE_checkPoint - 1].value
# 下一步，在发送接口请求之前，需要处理数据依赖
if relyData:
# 需要进行数据依赖处理
requestData = GetRelyValue.get(requestData, relyData)
print(requestData)
else:
print("第%s个API的第%s条不需要做数据依赖处理！" %((idx -1), (c_idx -1)))
if requestData[0] == "{" and requestData[-1] == "}":
# 说明请求参数是一个json串格式数据
requestData = eval(requestData)
if apiName == "login":
# 处理登录时密码加密
requestData["password"] = md5_encrypt(requestData["password"])
# 处理完接口请求参数的依赖数据后，接下来就是发送请求并获取响应结果
response = HttpClient.request(requestUrl, requestMethod, paramsType, requestData)
# 下一步，根据接口响应结果，做数据依赖存储以及结果检测
if response.status_code == 200:
# 获取接口的响应body
responseBody = response.json()
# 接下来做数据依赖存储
if dataStore:
RelyDataStore.do(apiName, c_idx-1, requestData, responseBody, eval(dataStore))
# 接下来进行接口响应结果检测
if checkPoint:
errorKey = CheckResult.check(response.json(), eval(checkPoint))
# 将测试结果写回excel
write_result(parseE, caseSheetObj, response.json(), errorKey, c_idx)
else:
print("第%s个API的第%s条case被忽略执行！" %((idx -1), (c_idx -1)))
else:
print("第%s个API被忽略执行！" %(idx -1))
def do_login():
logging.info('Starting to login...')
username_ = Configuration.UESRNAME
pwd_ = Configuration.PASSWORD
""""
Perform login action with use name, password and saving cookies.
@param username_: login user name
@param pwd_: login password
@param cookie_file_: file name where to save cookies when login succeeded
"""
# POST data per login weibo, these fields can be captured using httpfox extension in Firefox
login_data_ = {
'entry': 'weibo',
'gateway': '1',
'from': '',
'savestate': '7',
'userticket': '1',
'pagerefer': '',
'vsnf': '1',
'su': '',
'service': 'miniblog',
'servertime': '',
'nonce': '',
'pwencode': 'rsa2',
'rsakv': '',
'sp': '',
'encoding': 'UTF-8',
'prelt': '45',
'url': 'http://weibo.com/ajaxlogin.php?framelogin=1&callback=parent.sinaSSOController.feedBackUrlCallBack',
'returntype': 'META'
}
login_url_ = 'http://login.sina.com.cn/sso/login.php?client=ssologin.js(v1.4.11)'
try:
server_time_, nonce_, rsakv_ = get_pre_login_status(username_)
except Exception as e:
logging.error(e)
return
# Fill POST data
print('starting to set login_data')
login_data_['servertime'] = server_time_
login_data_['nonce'] = nonce_
login_data_['su'] = get_user(username_)
login_data_['sp'] = get_pwd_rsa(pwd_, server_time_, nonce_)
login_data_['rsakv'] = rsakv_
text_ = HttpClient.get(login_url_, login_data_)
text_ = StringUtils.convert_to_str(text_, Charset.GBK)
p_ = re.compile('location\.replace\(\'(.*?)\'\)')
try:
# Search login redirection URL
login_url_ = p_.search(text_).group(1)
data_ = HttpClient.get(login_url_)
data_ = StringUtils.convert_to_str(data_, Charset.GBK)
#Verify login feedback, check whether result is TRUE
patt_feedback_ = 'feedBackUrlCallBack\((.*)\)'
p_ = re.compile(patt_feedback_, re.MULTILINE)
feedback_ = p_.search(data_).group(1)
feedback_json_ = json.loads(feedback_)
if feedback_json_['result']:
HttpClient.save_cookie_in_file()
except Exception as e:
logging.error(e)
