def __init__(self):
unittest.TestCase.__init__(self)
xiao_iron = 'E:/xt/xironbardepend/xironbackend/'
self.run_method = RunMethod()
self.data = GetData(xiao_iron + 'dataconfig/interfacebar1.xlsx', 2)
self.send_mai = SendEmail()
self.read_int = ReadIni()
def __init__(self, sheet_id):
self.sheet_id = sheet_id
self.run_method = RunMethod()
# 传递 sheet_id
self.data = GetData(self.sheet_id)
self.com_util = CommonUtil()
'''
def __init__(self):
unittest.TestCase.__init__(self)
xiao_iron = 'E:/xt/xtcontract/xironbackend/dataconfig/'
self.run_method = RunMethod()
self.data = GetData(xiao_iron + 'interfacebar1.xlsx', 8)
self.send_mai = SendEmail()
self.read_int = ReadIni()
self.statistic = Dict()
self.excel_prop = Dict()
def run_dependent(self):
run_method = RunMethod()
row_num = self.opera_excel.get_row_num(self.case_id)
request_data = self.data.get_data_for_json(row_num)
header = self.data.is_header(row_num)
method = self.data.get_request_method(row_num)
url = self.data.get_request_url(row_num)
res = run_method.run_main(method, url, request_data, header)
return res
def setUp(self):
self.run = RunMethod()
with open('{}'.format(
os.path.join(os.path.dirname(os.getcwd()), 'Config') +
'\conf.yaml'),
"r",
encoding="utf-8") as r:
config = yaml.load(r) # 解析并读写yaml文件
self.app_host = config['app_host']
self.headers = config['app_headers']
def setUpClass(cls):
host = cls.host
lujing = 'query_token'
text = '{"OperatorID":"MA005DBW1","OperatorSecret":"2019092301abcdef"}'
encrypt_data = encrypt(cls.DataSecret, text)
data = {
"OperatorID":
cls.operator_id,
"Data":
"{}".format(encrypt_data),
"TimeStamp":
"{}".format(cls.times),
"Seq":
"0001",
"Sig":
"{}".format(
hmac_md5(cls.SigSecret,
cls.operator_id + encrypt_data + cls.times + "0001"))
}
headers = cls.headers
res = RunMethod().run_main('post', host, lujing, data, headers)
# res = requests.post(url=host + lujing, data=data, headers=header
print(res)
token = eval(decrypt(cls.DataSecret, res['Data']))['AccessToken']
cls.headers['Authorization'] = 'Bearer ' + token
return cls.headers
def test1_query_stations_info(self, text):
'''
查询充电站信息
:return:
'''
print(self.headers)
host = self.host
lujing = 'query_stations_info'
encrypt_data = encrypt(self.DataSecret, text)
data = {
"OperatorID":
self.operator_id,
"Data":
"{}".format(encrypt_data),
"TimeStamp":
"{}".format(self.times),
"Seq":
"0001",
"Sig":
"{}".format(
hmac_md5(self.SigSecret, self.operator_id + encrypt_data +
self.times + "0001"))
}
headers = self.headers
res = RunMethod().run_main('post', host, lujing, data, headers)
miaoshu(url=host + lujing,
method="post",
data=text,
check="{Ret and Msg}",
respons=res)
def test1_query_equip_auth(self):
'''
请求设备认证
:return:
'''
host = self.host
lujing = 'query_equip_auth'
text = {
"EquipAuthSeq": "{}".format(self.EquipAuthSeq),
"ConnectorID": self.connID
}
encrypt_data = encrypt(self.DataSecret, str(text))
data = {
"OperatorID":
self.operator_id,
"Data":
"{}".format(encrypt_data),
"TimeStamp":
"{}".format(self.times),
"Seq":
"0001",
"Sig":
"{}".format(
hmac_md5(self.SigSecret, self.operator_id + encrypt_data +
self.times + "0001"))
}
headers = self.headers
res = RunMethod().run_main('post', host, lujing, data, headers)
undata = eval(decrypt(self.DataSecret, res['Data']))
miaoshu(url=host + lujing,
method="post",
data=text,
check="{Ret and Msg}",
respons=undata)
def test3_query_station_status(self):
'''
设备接口状态查询
:return:
'''
host = self.host
lujing = 'query_station_status'
text = {"StationIDs": ["{}".format(self.stationID)]}
encrypt_data = encrypt(self.DataSecret, str(text))
data = {
"OperatorID":
self.operator_id,
"Data":
"{}".format(encrypt_data),
"TimeStamp":
"{}".format(self.times),
"Seq":
"0001",
"Sig":
"{}".format(
hmac_md5(self.SigSecret, self.operator_id + encrypt_data +
self.times + "0001"))
}
headers = self.headers
res = RunMethod().run_main('post', host, lujing, data, headers)
undata = eval(decrypt(self.DataSecret, res['Data']))
miaoshu(url=host + lujing,
method="post",
data=text,
check="{'StationIDs', 'ConnectorStatusInfos'}",
respons=undata)
self.assertTrue(res['Ret'] == 0, msg="状态码不正确")
self.assertIn('StationStatusInfos', undata, msg='返回内容不正确')
def test3_dataMiSS_OperatorID(self):
'''
检验post参数不合法,缺少必须参数OperatorID
:return:
'''
host = self.host
lujing = 'query_token'
data = {
"Data": "{}".format(self.encrypt_data),
"TimeStamp": "{}".format(self.times),
"Seq": "0001",
"Sig": "{}".format(self.sig)
}
headers = self.headers
res = RunMethod().run_main('post', host, lujing, data, headers)
miaoshu(url=host + lujing,
method="post",
data=data,
check="{'Ret': 4003 'Msg': 'POST参数不合法,缺少必须的示例'}",
respons=res)
self.assertTrue(res['Ret'] == 4003, msg="状态码不正确")
self.assertTrue(
res['Msg'] ==
"POST参数不合法,缺少必须的示例：OperatorID,sig,TimeStamp,Data，Seq五个参数",
msg="返回msg不正确")
def test1_alldata_right(self):
'''
检验所有参数正确
:return:
'''
host = self.host
lujing = 'query_token'
data = {
"OperatorID": "359705330",
"Data": "{}".format(self.encrypt_data),
"TimeStamp": "{}".format(self.times),
"Seq": "0001",
"Sig": "{}".format(self.sig)
}
headers = self.headers
res = RunMethod().run_main('post', host, lujing, data, headers)
miaoshu(url=host + lujing,
method="post",
data=data,
check="{'Ret': 0, 'Msg': '请求成功'}",
respons=res)
print(res)
self.assertTrue(res['Ret'] == 0, msg="状态码不正确")
self.assertTrue(res['Msg'] == "请求成功", msg="返回msg不正确")
def test8_datafield_error(self):
'''
检验请求的业务参数不合法(字段命名不正确)
:return:
'''
host = self.host
lujing = 'query_token'
text = '{"OperatorID":"359705330","OperatorSecret11":"11"}'
encrypt_data = encrypt(self.DataSecret, text)
print(encrypt_data)
data = {
"OperatorID":
"MA35PU38X",
"Data":
"{}".format(encrypt_data),
"TimeStamp":
"{}".format(self.times),
"Seq":
"0001",
"Sig":
"{}".format(
hmac_md5(self.SigSecret,
"359705330" + encrypt_data + self.times + "0001"))
}
headers = self.headers
res = RunMethod().run_main('post', host, lujing, data, headers)
print("请求的业务参数:{}".format(text))
miaoshu(url=host + lujing,
method="post",
data=data,
check="{'Ret': 4004 'Msg': '请求的业务参数不合法，各接口定义自己的必须参数'}",
respons=res)
self.assertTrue(res['Ret'] == 4004, msg="状态码不正确")
self.assertTrue(res['Msg'] == "请求的业务参数不合法，各接口定义自己的必须参数")
def test5_dataMiSS_TimeStamp(self):
'''
检验post参数不合法,缺少必须参数TimeStamp
:return:
'''
encrypt_data = encrypt(self.DataSecret, self.text)
sig = hmac_md5(self.SigSecret,
"359705330" + encrypt_data + self.times + "0001")
host = self.host
lujing = 'query_token'
data = {
"OperatorID": "359705330",
"Data": "{}".format(encrypt_data),
"Seq": "0001",
"Sig": "{}".format(sig)
}
headers = self.headers
res = RunMethod().run_main('post', host, lujing, data, headers)
miaoshu(url=host + lujing,
method="post",
data=data,
check="{'Ret': 4003 'Msg': 'POST参数不合法,缺少必须的示例'}",
respons=res)
self.assertTrue(res['Ret'] == 4003, msg="状态码不正确")
self.assertTrue(
res['Msg'] ==
"POST参数不合法,缺少必须的示例：OperatorID,sig,TimeStamp,Data，Seq五个参数",
msg="返回msg不正确")
def setUpClass(cls):
host = cls.host
lujing = 'query_token'
text = '{"OperatorID":"MA59CU773","OperatorSecret":"7iPn98cO06iK6oP7"}'
encrypt_data = encrypt(cls.DataSecret, text)
print(encrypt_data)
data = {
"OperatorID":
cls.operator_id,
"Data":
"{}".format(encrypt_data),
"TimeStamp":
"{}".format(cls.times),
"Seq":
"0001",
"Sig":
"{}".format(
hmac_md5(cls.SigSecret,
cls.operator_id + encrypt_data + cls.times + "0001"))
}
headers = cls.headers
res = RunMethod().run_main('post', host, lujing, data, headers)
token = eval(decrypt(cls.DataSecret, res['Data']))['AccessToken']
cls.headers['Authorization'] = 'Bearer ' + token
return cls.headers
def test4_query_notification_start_charge_result(self, text):
'''
推送充电结果
:return:
'''
host = self.host
lujing = 'query_notification_start_charge_result'
# text = {"StartChargeSeq": "{}".format(self.order), "ConnectorID": "{}".format(self.connID)}
encrypt_data = encrypt(self.DataSecret, str(text))
data = {
"OperatorID":
self.operator_id,
"Data":
"{}".format(encrypt_data),
"TimeStamp":
"{}".format(self.times),
"Seq":
"0001",
"Sig":
"{}".format(
hmac_md5(self.SigSecret, self.operator_id + encrypt_data +
self.times + "0001"))
}
headers = self.headers
res = RunMethod().run_main('post', host, lujing, data, headers)
print(res)
# undata = eval(decrypt(self.DataSecret, res['Data']))
miaoshu(url=host + lujing,
method="post",
data=text,
check="{Ret and Msg}",
respons=res)
def test5_query_equip_charge_status(self):
'''
查询充电状态
:return:
'''
host = self.host
lujing = 'query_equip_charge_status'
text = {"StartChargeSeq": "{}".format(self.order)}
encrypt_data = encrypt(self.DataSecret, str(text))
data = {
"OperatorID":
self.operator_id,
"Data":
"{}".format(encrypt_data),
"TimeStamp":
"{}".format(self.times),
"Seq":
"0001",
"Sig":
"{}".format(
hmac_md5(self.SigSecret, self.operator_id + encrypt_data +
self.times + "0001"))
}
headers = self.headers
res = RunMethod().run_main('post', host, lujing, data, headers)
miaoshu(url=host + lujing,
method="post",
data=text,
check="{Ret and Msg}",
respons=res)
self.assertTrue(res['Ret'] == 0, msg="状态码不正确")
self.assertTrue(res['Msg'] == "请求成功", msg="返回msg不正确")
class RunTest:
def __init__(self, sheet_id):
self.sheet_id = sheet_id
self.run_method = RunMethod()
# 传递 sheet_id
self.data = GetData(self.sheet_id)
self.com_util = CommonUtil()
'''
# 获取excel行数,也就是case条数
self.rows_count = self.data.get_case_lines()
'''
# 程序执行的
def go_on_run(self, i):
pass_count = []
fail_count = []
# 改成手动单个单个去执行每行
is_run = self.data.get_is_run(i)
if is_run:
url = self.data.get_request_url(i)
method = self.data.get_request_method(i)
header = self.data.is_header(i)
request_data = self.data.get_data_for_json(i) # 通过关键字调用
#
# request_data = self.data.get_request_data(i)
expect = self.data.get_expect_data(i)
# expect = self.data.get_expcet_data_for_sql(i)
# 获取依赖case_id
depend_case = self.data.is_depend(i)
if depend_case != None:
# 传case_id的值
self.depend_data = DependentData(depend_case, self.sheet_id)
# 获取的依赖响应数据
depend_response_data = self.depend_data.get_data_for_key(i)
# 获取依赖的key字段
depend_key = self.data.get_depend_field(i)
request_data[depend_key] = depend_response_data
res = self.run_method.run_main(method, url, request_data, header)
# 转str类型打印
jres = json.dumps(res,
ensure_ascii=False,
sort_keys=True,
indent=2)
if self.com_util.is_contain(expect, jres):
self.data.write_result(i, 'PASS')
pass_count.append(i)
else:
self.data.write_result(i, jres)
fail_count.append(i)
return expect, jres
return str(self.sheet_id), str(self.sheet_id)
def test_check_order(self):
"""
检查订单状态
:return:
"""
Log().debug("正在执行:检查订单状态")
lujing = "/loan/order/check/"
headers = self.app_headers
res = RunMethod().run_main("get",
self.app_host,
lujing,
headers=headers)
self.assertEqual(res["code"], 200)
print(res)
def user_Session():
with open('{}'.format(
os.path.join(os.path.dirname(os.getcwd()), 'Config') +
'\conf.yaml'),
"r",
encoding="utf-8") as r:
config = yaml.load(r) # 解析并读写yaml文件
lujing = '/users/loginByPwd'
host = config['app_host']
datas = config['user_info']
headers = config['app_headers']
res = RunMethod().run_main("post", host, lujing, datas, headers)
# print(res)
write_yaml_variable("X-SessionToken-With", res['data'])
def test_login_pwd(self, data):
'''
66快充登录:密码方式
:param datas:
:return:
'''
host = self.app_host
headers = self.headers
lujing = '/customer/v1/member/login'
res = RunMethod().run_main('post', host, lujing, data, headers)
# self.assertTrue(res['code'] == 0, msg=res['msg'])
miaoshu(url=host + lujing,
method='post',
data=data,
check={"code and msg"},
respons=res)
class sms(unittest.TestCase):
def setUp(self):
self.run = RunMethod()
with open('{}'.format(
os.path.join(os.path.dirname(os.getcwd()), 'Config') +
'\conf.yaml'),
"r",
encoding="utf-8") as r:
config = yaml.load(r) # 解析并读写yaml文件
self.app_host = config['app_host']
self.headers = config['app_headers']
def tearDown(self):
pass
@data({
"phone": "18657738815",
"type": 3,
"voice": 0
}, {
"phone": "18657738816",
"type": 1,
"voice": 0
}, {
"phone": "18657738817",
"type": 2,
"voice": 0
}, {})
def test_send_sms(self, data):
"""
登录页发送短信验证码
:return:
"""
# time.sleep()
host = self.app_host
headers = self.headers
lujing = '/system/v1/message_code/send'
res = self.run.run_main('post', host, lujing, data, headers)
# self.assertTrue(res['code'] == 0, msg=res['msg'])
miaoshu(url=host + lujing,
method='post',
data=data,
check={'code and msg'},
respons=res)
def test4_query_stations_stats(self):
'''
查询统计信息
:return:
'''
host = self.host
lujing = 'query_station_stats'
text = {
"StationID": "{}".format(self.stationID),
"StartTime": "2019-10-20",
"EndTime": "2019-11-20"
}
encrypt_data = encrypt(self.DataSecret, str(text))
data = {
"OperatorID":
self.operator_id,
"Data":
"{}".format(encrypt_data),
"TimeStamp":
"{}".format(self.times),
"Seq":
"0001",
"Sig":
"{}".format(
hmac_md5(self.SigSecret, self.operator_id + encrypt_data +
self.times + "0001"))
}
headers = self.headers
res = RunMethod().run_main('post', host, lujing, data, headers)
# res = requests.post(url=host + lujing, json=data, headers=headers)
undata = eval(decrypt(self.DataSecret, res['Data']))
miaoshu(url=host + lujing,
method="post",
data=text,
check="{'Ret': 0, 'Msg': '请求成功',}",
respons=undata)
self.assertTrue(res['Ret'] == 0, msg="状态码不正确")
self.assertIn('StationStatsInfo', undata, msg='返回内容不正确')
def test2_notification_stationStatus(self):
'''
设备状态变化推送
:return:
'''
host = self.host
lujing = 'notification_stationStatus'
text = {
"ConnectorStatusInfo": [{
"ConnectorID": "{}".format(self.connID),
"Status": 1
}]
}
encrypt_data = encrypt(self.DataSecret, str(text))
data = {
"OperatorID":
self.operator_id,
"Data":
"{}".format(encrypt_data),
"TimeStamp":
"{}".format(self.times),
"Seq":
"0001",
"Sig":
"{}".format(
hmac_md5(self.SigSecret, self.operator_id + encrypt_data +
self.times + "0001"))
}
headers = self.headers
res = RunMethod().run_main('post', host, lujing, data, headers)
miaoshu(url=host + lujing,
method="post",
data=text,
check="{'Ret': 0, 'Msg': '请求成功',}",
respons=res)
self.assertTrue(res.status_code == 200, msg="状态码不正确")
def test2_sig_error(self):
'''
检验签名错误
:return:
'''
host = self.host
lujing = 'query_token'
data = {
"OperatorID": "359705330",
"Data": "{}".format(self.encrypt_data),
"TimeStamp": "20190619133716",
"Seq": "0001",
"Sig": "{}".format(self.sig)
}
headers = self.headers
res = RunMethod().run_main('post', host, lujing, data, headers)
miaoshu(url=host + lujing,
method="post",
data=data,
check="{'Ret': 4001, 'Msg': '签名错误'}",
respons=res)
self.assertTrue(res['Ret'] == 4001, msg="状态码不正确")
self.assertTrue(res['Msg'] == "签名错误", msg="返回msg不正确")
def test_dingjia_shenqing(self):
'''
车商定价申请
:return:sq_id
'''
Log().debug("正在执行:定价申请——通过流程")
# print("头部信息为：%s" % cls.headers)
datas = {
"carConfigInstructionImage": [],
"carQualifiedImage": "",
"invoicePrice": "100008",
"price": "388.80",
"carNameplateImage": "",
"dealerCarId": "5c1b70d6cec76d6f353db12d"
}
lujing = '/carmall/applyDealerCarEnquiry/apply'
lujing = '/carmall/applyDealerCarEnquiry/apply'
res = RunMethod().run_main('post', self.app_host, lujing, datas,
self.app_headers)
write_yaml_variable("data", res['data'])
print(res['data'])
self.assertTrue(str(res['code']) == '200', msg='状态不对')
self.assertIn('success', res['msg'], msg='a不在b中')
class RunTest(unittest.TestCase):
def __init__(self):
unittest.TestCase.__init__(self)
xiao_iron = 'E:/xt/xironbardepend/xironbackend/'
self.run_method = RunMethod()
self.data = GetData(xiao_iron + 'dataconfig/interfacebar1.xlsx', 2)
self.send_mai = SendEmail()
self.read_int = ReadIni()
# 程序执行的
def go_on_run(self):
res = None
rows_count = self.data.get_case_lines()
success_count = 0
fail_count = 0
total_count = 0
for i in range(1, rows_count):
is_run = self.data.get_is_run(i)
if is_run:
url = self.read_int.get_value() + self.data.get_url(i)
method = self.data.get_request_method(i)
request_data = self.data.get_data_for_json(i)
header = self.data.get_header(i)
depend_case = self.data.is_depend(i)
if depend_case is not None:
self.depend_data = DependentData(depend_case)
# 获取的依赖响应数据
depend_response_data = self.depend_data.get_data_for_key(i)
# 获取依赖的key
depend_key = self.data.get_depend_field(i)
if depend_key is None: # 如果依赖字段为空，则替换 url 中的{id}
url = url.replace('{id}', depend_response_data)
else: # 如果依赖字段有值，则更改请求字段对应的 depend_key 的 value为依赖请求的结果
request_data[depend_key] = depend_response_data
if method != 'get':
request_data = json.dumps(request_data)
total_count += 1
res = self.run_method.run_main(method, url, request_data, header)
expect_res_str = self.data.get_expect_data(i).__str__()
if expect_res_str is not None:
expect_res_list = expect_res_str.split('/')
all_expect_pass = True
for a in expect_res_list:
# 断言报错继续执行
try:
# self.assertIn(self.data.get_expect_data(i), json.dumps(res), "返回结果不是期望结果")
# 因为返回结果中不会有中文，所以将期望值的中文转成 Unicode 的 byte ，为了匹配 assertIn 的参数类型，再转成 utf-8的str
self.assertIn(a.encode("unicode_escape").decode('utf-8'), json.dumps(res), "返回结果不是期望结果")
print("用例编号：", self.data.get_case_id(i), ",接口自动化测试通过")
self.data.write_result(i, 'pass')
except AssertionError as e:
print("用例编号：", self.data.get_case_id(i), ",接口自动化测试失败!!!\n", "断言异常为：", e)
self.data.write_result(i, 'fail' + e.__str__().encode("utf-8").decode('utf-8'))
# fail_count += 1
all_expect_pass = False
if all_expect_pass:
success_count += 1
else:
fail_count += 1
else:
# 断言报错继续执行
try:
self.assertEqual(res.status_code, 204, '该操作不成功，无返回结果')
print("用例编号：", self.data.get_case_id(i), ",接口自动化测试通过")
self.data.write_result(i, 'pass')
success_count += 1
except AssertionError as e:
print("用例编号：", self.data.get_case_id(i), ",接口自动化测试失败!!!\n", "断言异常为：", e)
self.data.write_result(i, 'fail' + e.__str__())
fail_count += 1
if type(res) is not dict:
self.data.write_res_to_pre(i, res.__str__().encode("utf-8").decode('utf-8'))
else:
# self.data.write_res_to_pre(i, json.dumps(res))
# 回写 excel时，通过json.dumps() 会将中文编译成 Unicode，这里直接处理成 str
# 结果回写需要是 json格式，将单引号换成双引号
pre_json = res.__str__().replace('\'', '\"')
self.data.write_res_to_pre(i, pre_json)
print("本次接口自动化测试运行用例总数：", total_count)
print("本次接口自动化测试通过用例数：", success_count)
print("本次接口自动化测试失败用例数：", fail_count)
def setUp(self):
self.run = RunMethod()
class login(unittest.TestCase):
def setUp(self):
self.run = RunMethod()
# pass
def tearDown(self):
pass
@data(
{
"mobile": "18657738815",
"password": "******"
}, {
"mobile": "13071863055",
"password": "******"
},
unpack=False)
def test_dealer_login(self, data):
'''
车商登陆:密码
:return:session
'''
host = 'http://192.168.31.172:8080'
lujing = '/dealer/login'
# datas = {"mobile": "18657738815", "password": "******"}
headers = {
"version": "2.0.0",
"Connection": "keep-alive",
"Content-Type": "application/json; charset=utf-8"
}
res = self.run.run_main('post',
host,
lujing,
data=data,
headers=headers)
self.assertTrue(str(res['code']) == '200', msg='状态不对')
self.assertIn('success', res['msg'], msg='a不在b中')
print(res)
@data(18657738815, 15805811478, 13071863055)
def test_cms_login(self, user):
"""后台登陆:密码
:return:cookie
"""
url = 'http://192.168.31.172:8082/cms/login'
datas = {"username": user, "password": 111111}
res = requests.post(url, datas)
response = res.json()
self.assertTrue(str(response['code']) == '200', msg='状态不对')
self.assertIn('success', response['msg'], msg='a不在b中')
print(response)
@data(["gold", 100], ["diamond", 500])
def test_bless(self, bless_type, award):
'''
领取宝箱
:param bless_type:
:param award:
:return:
'''
print(bless_type)
print(award)
class RunTest(unittest.TestCase):
def __init__(self):
unittest.TestCase.__init__(self)
xiao_iron = 'E:/xt/xtcontract/xironbackend/dataconfig/'
self.run_method = RunMethod()
self.data = GetData(xiao_iron + 'interfacebar1.xlsx', 8)
self.send_mai = SendEmail()
self.read_int = ReadIni()
self.statistic = Dict()
self.excel_prop = Dict()
# 程序执行的
def go_on_run(self):
self.excel_prop.rows_count = self.data.get_case_lines()
self.statistic.success_count = 0
self.statistic.fail_count = 0
self.statistic.total_count = 0
for i in range(2, self.excel_prop.rows_count):
self.excel_prop.index = i
self.excel_prop.is_run = self.data.get_is_run(i)
if self.excel_prop.is_run:
self.excel_prop.url = self.read_int.get_value(
) + self.data.get_url(i)
self.excel_prop.method = self.data.get_request_method(i)
self.excel_prop.request_data = self.data.get_data_for_json(i)
self.excel_prop.header = self.data.get_header(i)
self.excel_prop.case_depend = self.data.get_case_depend(i)
if self.excel_prop.case_depend is not None and CommonUtil.is_json(
self.excel_prop.case_depend):
self.depend_data_json = DependentDataJson(self.excel_prop)
self.excel_prop = self.depend_data_json.assemble_excel_prop(
)
if self.excel_prop.method != 'get':
self.excel_prop.request_data = json.dumps(
self.excel_prop.request_data)
self.statistic.total_count += 1
res = self.run_method.run_main(self.excel_prop.method,
self.excel_prop.url,
self.excel_prop.request_data,
self.excel_prop.header)
self.excel_prop.expect_res_str = self.data.get_expect_data(
i).__str__()
if self.excel_prop.expect_res_str is not None:
expect_res_list = self.excel_prop.expect_res_str.split('/')
all_expect_pass = True
for expect_res in expect_res_list:
# 断言报错继续执行
try:
# 因为返回结果中不会有中文，所以将期望值的中文转成 Unicode 的 byte ，为了匹配 assertIn 的参数类型，再转成 utf-8的str
self.assertIn(
expect_res.encode("unicode_escape").decode(
'utf-8'), json.dumps(res), "返回结果不是期望结果")
print("用例编号：", self.data.get_case_id(i),
",接口自动化测试通过")
self.data.write_result(i, 'pass')
except AssertionError as e:
print("用例编号：", self.data.get_case_id(i),
",接口自动化测试失败!!!\n", "断言异常为：", e)
self.data.write_result(
i, 'fail' +
e.__str__().encode("utf-8").decode('utf-8'))
# self.statistic.fail_count += 1
all_expect_pass = False
if all_expect_pass:
self.statistic.success_count += 1
else:
self.statistic.fail_count += 1
else:
# 断言报错继续执行
try:
self.assertEqual(res.status_code, 204, '该操作不成功，无返回结果')
print("用例编号：", self.data.get_case_id(i), ",接口自动化测试通过")
self.data.write_result(i, 'pass')
self.statistic.success_count += 1
except AssertionError as e:
print("用例编号：", self.data.get_case_id(i),
",接口自动化测试失败!!!\n", "断言异常为：", e)
self.data.write_result(i, 'fail' + e.__str__())
self.statistic.fail_count += 1
if type(res) is not dict:
self.data.write_res_to_pre(
i,
res.__str__().encode("utf-8").decode('utf-8'))
else:
# 回写 excel时，通过json.dumps() 会将中文编译成 Unicode，这里直接处理成 str
# 结果回写需要是 json格式，将单引号换成双引号
pre_json = res.__str__().replace('\'', '\"')
self.data.write_res_to_pre(i, pre_json)
print("本次接口自动化测试运行用例总数：", self.statistic.total_count)
print("本次接口自动化测试通过用例数：", self.statistic.success_count)
print("本次接口自动化测试失败用例数：", self.statistic.fail_count)
