import unittest
from pip._vendor import requests
from common.read_excel import ReadExcel
from common.send_request import SendRequest
from common.sql_data import SqlData
updateRegionShippingFee_data = ReadExcel().readExcel(
r'../data/updateRegionShippingFee_api.xlsx', 'Sheet1')
s = requests.session()
class UpdateRegionShippingFee(unittest.TestCase):
'''更新国家运费'''
@classmethod
def setUpClass(cls):
for i in range(len(updateRegionShippingFee_data)):
if updateRegionShippingFee_data[i][
'sql'] != '' and '{parent_sku}' in updateRegionShippingFee_data[
i]['body']:
a = SqlData.themis_data(updateRegionShippingFee_data[i]['sql'])
updateRegionShippingFee_data[i][
'body'] = updateRegionShippingFee_data[i]['body'].replace(
'{parent_sku}', str(a[i]))
else:
continue
def test_updateRegionShippingFee1(self):
'''token与运费参数都正确'''
r = SendRequest.sendRequest(s, updateRegionShippingFee_data[0])
expect_result = updateRegionShippingFee_data[0]['expect_result'].split(
import requests
import unittest
from ddt import ddt, data
from common.read_excel import ReadExcel
wb = ReadExcel('data/case001.xlsx', 'sheet1')
cases = wb.r_data_obj([1, 2, 3])
@ddt
class RegisterTestCase(unittest.TestCase):
def __init__(self, methodName, case_obj):
self.excepted = eval(case_obj.excepted)
self.data = eval(case_obj.data)
self.row = case_obj.case_id + 1
super().__init__(methodName)
def setUp(self) -> None:
pass
def tearDown(self) -> None:
pass
@data(*cases)
def test_register(self, case):
self.row = case.case_id + 1
res = register(*eval(case.data))
try:
self.assertEqual(eval(case.excepted), res)
except AssertionError as e:
res = '失败'
},
{
"username": "******",
"password": "******",
"expect": "余振新",
"result": False
},
]
# 读取excel
# fliepath = r"D:\Web_project\demo\data\datas.xlsx"
propath = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
filepath = os.path.join(propath, "data", "datas.xlsx")
sheetName = "Sheet1"
data = ReadExcel(filepath, sheetName)
print(data.dict_data())
url = "http://180.106.83.239:18080/login.html"
"""
测试数据驱动：
test_01: 输入账号密码后点击登录，获取登录名，判断登录名是否符合预期来断言是否登录成功
（登录失败会有弹窗，无法进入登录成功后的页面，定位登录名会抛出TimeOut异常，实际用例执行成功，但用例会执行失败）
test_02: 输入账号密码后点击登录，获取登录名，判断登录名是否符合预期来断言是否登录成功
（在测试数据增加“result”字段，赋值True or False，
调用common方法返回预期与实际为True or False后，与“result”断言，解决没有获取到登录名会使用例失败的问题）
"""
@ddt.ddt
class TestDemo(unittest.TestCase):
def __init__(self, case_id):
self.case_id = case_id
self.read_excel = ReadExcel()
self.data = GetData()
class GetListTestCase(unittest.TestCase):
# 拼接完整的excel路径，然后读取excel数据
wb = ReadExcel(os.path.join(DATA_DIR, file_name), "getList")
cases = wb.read_column_data(read_column)
@classmethod
def setUpClass(cls):
my_log.info(
"============================== 准备开始执行获取各种列表接口的测试 ==============================="
)
cls.request = HTTPRequest2()
cls.db = ExecuteMysql()
@classmethod
def tearDownClass(cls):
my_log.info(
"============================== 获取各种列表接口测试执行完毕 =============================="
)
cls.request.close()
cls.db.close()
@data(*cases) # 拆包，拆成几个参数
def test_get_list(self, case):
if "#nomemberid#" in case.request_data:
memberid = self.db.find_one("SELECT MAX(Id) FROM member")[0] + 1
case.request_data = case.request_data.replace(
"#nomemberid#", str(memberid))
if "#noloanid#" in case.request_data:
loanid = self.db.find_one("SELECT MAX(Id) FROM loan")[0] + 1
case.request_data = case.request_data.replace(
"#noloanid#", str(loanid))
case.request_data = data_replace(case.request_data)
# 拼接url地址，发送请求
url = conf.get("env", "url") + case.url
self.row = case.case_id + 1
response = self.request.request(method=case.method,
url=url,
data=eval(
case.request_data)) # 将str转换成dict
if case.check_mysql:
if "MemberId=#memberid6#" in case.check_mysql:
case.check_mysql = data_replace(case.check_mysql)
loanid = self.db.find_one(case.check_mysql)[0]
setattr(ConText, "loanid", str(loanid))
# 该打印的内容会显示在报告中
print("请求数据--> {}".format(case.request_data))
print("期望结果---> {}".format(case.expected_data))
print("服务器响应数据--> {}".format(response.json()))
# res = response.json()返回json格式，自动转换成Python的dict类型，只取部分字段进行断言
res = {
"status": response.json()["status"],
"code": response.json()["code"]
}
try:
self.assertEqual(eval(case.expected_data), res)
except AssertionError as e:
result = 'FAIL'
my_log.exception(e) # 将异常信息记录到日志
raise e
else:
result = 'PASS'
my_log.debug("预期结果：%s, 实际结果：%s, 测试通过" %
(eval(case.expected_data), res))
finally:
self.wb.write_data(row=self.row, column=10, value=str(res))
self.wb.write_data(row=self.row, column=11, value=result)
class LoginTestCase(unittest.TestCase):
# 拼接完整的excel路径，然后读取excel数据
wb = ReadExcel(os.path.join(DATA_DIR, file_name), "login")
cases = wb.read_column_data(read_column)
@classmethod
def setUpClass(cls):
my_log.info(
"=============================== 准备开始执行登录接口的测试 =============================="
)
cls.request = HTTPRequest2()
cls.db = ExecuteMysql()
@classmethod
def tearDownClass(cls):
my_log.info(
"=============================== 登录接口测试执行完毕 =============================="
)
cls.request.close()
@data(*cases) # 拆包，拆成几个参数
def test_login(self, case):
# 筛选用例的请求数据中做了#register__phone#标记的数据
if "#register_phone#" in case.request_data:
while True:
# 生成随机号码
mobile_phone = rand_phone("138")
# 查询数据库有无该随机号码
count = self.db.find_count(
"SELECT Id FROM member WHERE MobilePhone={}".format(
mobile_phone))
# 数据库中无此随机号码，就不用继续随机生成，直接使用该随机号码
if count == 0:
break
# 将用例中的#register__phone#替换成随机生成的手机号码
case.request_data = case.request_data = case.request_data.replace(
"#register_phone#", mobile_phone)
# 选取请求的电话号为已注册的测试用例数据
elif "#exists_phone#" in case.request_data:
# 从数据库获取第一条号码，给用例参数
mobile_phone = self.db.find_one(
"SELECT MobilePhone FROM member LIMIT 1")[0]
# 用从数据库获取的号码替换掉请求数据中的标记#exists_phone
case.request_data = case.request_data.replace(
"#exists_phone#", mobile_phone)
case.request_data = data_replace(case.request_data)
# 拼接url地址
url = conf.get("env", "url") + case.url
self.row = case.case_id + 1
response = self.request.request(method=case.method,
url=url,
data=eval(case.request_data))
# 该打印的内容会显示在报告中
print("请求数据--> {}".format(case.request_data))
print("期望结果--> {}".format(case.expected_data))
print("服务器响应数据--> {}".format(response.json()))
res = response.json()
try:
self.assertEqual(eval(case.expected_data), res)
except AssertionError as e:
result = 'FAIL'
my_log.exception(e) # 将异常信息记录到日志
raise e
else:
result = 'PASS'
my_log.debug("预期结果：%s, 实际结果：%s, 测试通过" %
(eval(case.expected_data), res))
finally:
self.wb.write_data(row=self.row, column=9, value=str(res))
self.wb.write_data(row=self.row, column=10, value=result)
class RechargeTestCase(unittest.TestCase):
# 拼接完整的excel路径，然后读取excel数据
wb = ReadExcel(os.path.join(DATA_DIR, file_name), "recharge")
# wb = ReadExcel(os.path.join(DATA_DIR, file_name), "Sheet1")
cases = wb.read_column_data(read_column)
@classmethod
def setUpClass(cls):
my_log.info(
"============================== 准备开始执行充值接口的测试 =============================="
)
cls.request = HTTPRequest2()
cls.db = ExecuteMysql()
@classmethod
def tearDownClass(cls):
my_log.info(
"============================== 充值接口测试执行完毕 =============================="
)
cls.request.close()
cls.db.close()
@data(*cases) # 拆包，拆成几个参数
def test_recharge(self, case):
# 筛选用例的请求数据中做了#register__phone#标记的数据
if "#register_phone#" in case.request_data:
while True:
# 生成随机号码
mobile_phone = rand_phone()
# 查询数据库有无该随机号码
count = self.db.find_count(
"SELECT Id FROM member WHERE MobilePhone={}".format(
mobile_phone))
# 数据库中无此随机号码，就不用继续随机生成，直接使用该随机号码
if count == 0:
break
# 将用例中的#register__phone#替换成随机生成的手机号码
case.request_data = case.request_data.replace(
"#register_phone#", mobile_phone)
# 选取请求的电话号为已注册的测试用例数据
if "#exists_phone#" in case.request_data:
# 从数据库获取第一条号码，给用例参数
mobile_phone = self.db.find_one(
"SELECT MobilePhone FROM member LIMIT 1")[0]
# 用从数据库获取的号码替换掉请求数据中的标记#exists_phone
case.request_data = case.request_data.replace(
"#exists_phone#", mobile_phone)
case.request_data = data_replace(case.request_data)
# 判断是否需要校验数据库
if case.check_mysql:
# 将登录手机号替换掉sql语句中的标记${login_phone}
# case.check_mysql = case.check_mysql.replace("${login_phone}", conf.get('test_data', "login_phone"))
case.check_mysql = data_replace(case.check_mysql)
# 调用查询数据方法，传入sql语句，返回元组，下标0取值,decimal
before_money = self.db.find_one(case.check_mysql)[0]
# 拼接url地址
url = conf.get("env", "url") + case.url
self.row = case.case_id + 1
response = self.request.request(method=case.method,
url=url,
data=eval(case.request_data))
# 该打印的内容会显示在报告中
print("请求数据--> {}".format(case.request_data))
print("期望结果--> {}".format(case.expected_data))
print("服务器响应数据--> {}".format(response.json()))
# res = response.json()返回json格式，自动转换成Python的dict类型，只取部分字段进行断言
res = {
"status": response.json()["status"],
"code": response.json()["code"],
"msg": response.json()["msg"]
}
try:
self.assertEqual(eval(case.expected_data), res)
if case.check_mysql:
# case.request_data是str类型，先转换为dict再来取值，float
money = eval(case.request_data)["amount"]
# 将float类型转换成decimal类型，与数据库查询的结果数据类型一致，并设置保留2位小数
money = Decimal.from_float(money).quantize(Decimal("0.00"))
after_money = self.db.find_one(case.check_mysql)[0]
# 该打印的内容会显示在报告中
print("充值前余额为：{}, 本次充值金额：{}, 充值后余额为:{}".format(
before_money, money, after_money))
self.assertEqual(before_money + money, after_money)
except AssertionError as e:
result = 'FAIL'
my_log.exception(e) # 将异常信息记录到日志
raise e
else:
result = 'PASS'
my_log.debug("预期结果：%s, 实际结果：%s, 测试通过" %
(eval(case.expected_data), res))
finally:
self.wb.write_data(row=self.row, column=10, value=str(res))
self.wb.write_data(row=self.row, column=11, value=result)
class TestWithDraw(unittest.TestCase):
datapath = os.path.join(DataDir, 'cases.xlsx')
excel = ReadExcel(datapath, 'withdraw')
withdraw_data = excel.read_excel()
rest = HanderRequest()
db = HandDB()
@classmethod
def setUpClass(cls):
phone = conf.get('login_data', 'phone')
setattr(TestData, 'phone', phone)
pwd = conf.get('login_data', 'pwd')
setattr(TestData, 'pwd', pwd)
@data(*withdraw_data)
def test_withdraw(self, case):
# 准备用例数据
# 拼接url
url = conf.get('env', 'url') + case['url']
method = case['method']
case['data'] = replace_data(case['data'])
data = eval(case['data'])
expected = eval(case['expected'])
row = case['case_id'] + 1
header = eval(conf.get('env', 'header'))
if case['interface'] != '登录':
header['Authorization'] = TestData.token_data
# 判断是否需要校验
if case['check_sql']:
sql = case['check_sql'].format(getattr(TestData, 'phone'))
# 获取充值前的余额
before_amount = self.db.get_one(sql)[0]
response = self.rest.send(url=url,
method=method,
json=data,
headers=header)
res = response.json()
if case['interface'] == '登录':
# 获取member_id
member_id = jsonpath.jsonpath(res, '$..id')[0]
setattr(TestData, 'member_id', str(member_id))
# 获取token类型
token_type = jsonpath.jsonpath(res, '$..token_type')[0]
# 获取token值
token = jsonpath.jsonpath(res, '$..token')[0]
token_data = token_type + ' ' + token
setattr(TestData, 'token_data', token_data)
try:
self.assertEqual(expected['code'], res['code'])
self.assertEqual(expected['msg'], res['msg'])
if case['check_sql']:
sql = case['check_sql'].format(getattr(TestData, 'phone'))
after_amount = self.db.get_one(sql)[0]
expected_amount = decimal.Decimal(str(data['amount']))
my_logger.info('提现前余额:{}\n,提现余额:{}\n,提现后余额:{}'.format(
before_amount, expected_amount, after_amount))
self.assertEqual(expected_amount,
(before_amount - after_amount))
except AssertionError as e:
self.excel.write_excel(row=row, column=8, value='未通过')
my_logger.info('用例-->{}:执行未通过'.format(case['title']))
my_logger.error(e)
print("预期结果：{}".format(expected))
print("实际结果：{}".format(res))
raise e
else:
self.excel.write_excel(row=row, column=8, value='已通过')
my_logger.info('用例-->{}:执行已通过'.format(case['title']))
@classmethod
def tearDownClass(cls):
cls.db.close()
功能：
1.获取excel返回数据
2.请求requests方法
3.断言
4.写入excel
'''
import unittest, json
from ddt import ddt, data, unpack
from common.read_excel import ReadExcel
from common.configHttp import ConfigHttp
from common.write_excel import WriteExcel
# 实例化
# 第一步：读取excel数据
re = ReadExcel()
testdata = re.addData()
# print(testdata)
# 实例化，以备调用封装好的requests方法
ch = ConfigHttp()
# 实例化，以备调用写入excel的方法
we = WriteExcel()
@ddt
class TestCase(unittest.TestCase):
@data(*testdata) # *args可变参数，传列表或元祖
@unpack # 分发
def test_normal(self, id, url, name, method, param, expect):
result = ch.getRequest(url, method, param)
class RequestMethod(object):
def __init__(self):
# 通过requests的session方法实例化一个session对象
self.session = requests.session()
# 实例化一个read_excel对象，用来进行表格数据读取操作
self.read_execl = ReadExcel()
# # 封装一个方法可以获得响应吗
# def get_response_code(self):
#
# 封装一个方法，发送get和post请求
def get_or_post(self, method, url, params=None):
# 根据传入方法参数的不同，通过使用session对象的不同方法使用不同的请求类型进行请求
# 方法的返回值是一个response对象
if method == 'GET':
return self.session.get(url=url, params=params, verify=False)
elif method == 'POST':
return self.session.post(url=url, data=params, verify=False)
else:
raise ValueError('请求类型不支持')
# 封装一个方法，请求结果获取响应body，可以用于正则提取，或者断言，如果返回json对象则返回字典数据，如果返回xml对象则返回text属性
def get_case_actual_result(self, method, url, response_data_type, params=None):
# 通过调用类方法get_or_post 来获得当前请求的响应对象
current_response = self.get_or_post(method=method, url=url, params=params)
# 将响应的解码为utf8
current_response.encoding = 'utf-8'
# 打印响应的文本
# print(current_response.text)
# 根据形参response_data_type的值，来返回不同的数据类型
if response_data_type == 'JSON':
# 调用response对象的.json方法获得当前响应的json返回数据 返回值为dict类型
return current_response.json()
elif response_data_type == 'XML':
# 返回response对象的text属性，获得text文本 返回值为str类型
return current_response.text
else:
# 如果没有获得想要的参数，则抛出一个传入值错误
raise ValueError('不支持响应数据类型')
# 声明一个方法根据前置用例id返回前置用例的行号 row
def get_case_precondition_row(self, row):
# 通过调用read_excel的get_case_precondition_id方法 获得当前用例的前置用例id
precondition_id = self.read_execl.get_case_precondition_id(row=row)
# 遍历所有行号
for row_01 in range(2, self.read_execl.get_row_count() + 1):
# 通过read_excel的get_case_id的到当前遍历行号的用例id
current_case_id = self.read_execl.get_case_id(row=row_01)
# 对比当前遍历行号的id与当前用例前置用例的id 如果相同则此行号为当前用例前置用例的行号
if current_case_id == precondition_id:
precondition_row = row_01
# 返回该行号
return precondition_row
# 声明一个方法根据前置用例的行号，获得前置用例的响应的结果 pre_row 返回值为响应的text或json的result
def get_case_precondition_response_result(self, precondition_row):
# 通过read_excel的get_response_data_type方法 获得前置用例的返回数据类型
pre_case_response_data_type = self.read_execl.get_case_response_data_type(row=precondition_row)
# 通过read_excel的get_case_method方法 获得前置用例的请求方法
pre_case_method = self.read_execl.get_case_method(row=precondition_row)
# 通过read_excel的get_case_url方法 获得前置用例的请求url
pre_case_url = self.read_execl.get_case_url(row=precondition_row)
# 通过read_excel的get_case_parameters_value 根据前置用例行号 获得前置用例的参数值
pre_case_params = self.read_execl.get_case_parameters_value(row=precondition_row)
# 通过调用类的get_actual方法 获得前置用例请求的响应结果
precondition_row_response_result = self.get_case_actual_result(method=pre_case_method, url=pre_case_url,
response_data_type=pre_case_response_data_type,
params=pre_case_params)
# 返回前置用例请求的响应结果
return precondition_row_response_result
# 声明一个方法，从响应中根据正则表达式提取value，与依赖字段组成键值对返回 pre_row dict数据类型
def get_depend_key_value_items(self, row):
# 调用类的get_case_precondition_row方法 获得前置用例的行号
# print('当前行数', row)
precondition_row = self.get_case_precondition_row(row=row)
# 通过调用read_excel的get_case_depend_field方法 获得前置用例的依赖字段的key值
depend_field_key = self.read_execl.get_case_depend_field(row=precondition_row)
# 通过调用类的get_case_precondition_response_result方法 传入前置用例的行号 获得前置用例的响应结果
pre_case_response_result = self.get_case_precondition_response_result(precondition_row=precondition_row)
# 通过调用read_excel的get_case_regular_expression传入前置用例行号 获得前置用例的正则表达式
pre_regular_expression = self.read_execl.get_case_regular_expression(row=precondition_row)
# 通过前置用例的正则表达式以及前置用例的响应结果，进行正则匹配，获得需求的依赖字段的值
depend_field_value = re.findall(pattern=pre_regular_expression, string=pre_case_response_result)[0]
# 以字典类型返回当钱用例的依赖字段的key与value
# print(depend_field_key, depend_field_value)
return {depend_field_key: depend_field_value}
# 声明一个方法，把正则表达式提取到的键值对，更新到请求参数中 row
def update_case_params_depend_field(self, row):
# 通过调用read_excel的get_case_parameters_value传入当前参数的行号，获得更新前的参数
require_params = self.read_execl.get_case_parameters_value(row=row)
# 通过调用类的get_depend_key_value_items获得当前用例的依赖字段的键值对
depend_filed = self.get_depend_key_value_items(row=row)
# 通过字典的update方法将依赖字段跟新到当前用例的所需参数中
require_params.update(depend_filed)
# 返回更新了依赖字段键值对的参数 作为当前用例的参数
return require_params
def __init__(self):
# 通过requests的session方法实例化一个session对象
self.session = requests.session()
# 实例化一个read_excel对象，用来进行表格数据读取操作
self.read_execl = ReadExcel()
def update_case_params_depend_field(self, row):
# 通过调用read_excel的get_case_parameters_value传入当前参数的行号，获得更新前的参数
require_params = self.read_execl.get_case_parameters_value(row=row)
# 通过调用类的get_depend_key_value_items获得当前用例的依赖字段的键值对
depend_filed = self.get_depend_key_value_items(row=row)
# 通过字典的update方法将依赖字段跟新到当前用例的所需参数中
require_params.update(depend_filed)
# 返回更新了依赖字段键值对的参数 作为当前用例的参数
return require_params
if __name__ == '__main__':
# 实例化request_method对象
request_method = RequestMethod()
# request_method.update_case_params_depend_field(8)
read_excel = ReadExcel()
# my_request = RequestMethod()
# rows = [2, 3, 4, 5, 6, 7, 10]
# for row in rows:
# method = read_excel.get_case_method(row=row)
# url = read_excel.get_case_url(row=row)
# params = read_excel.get_case_parameters_value(row)
# content_type = read_excel.get_response_data_type(row)
# print('当前响应数据类型')
# print(read_excel.get_case_id(row=row))
# print(my_request.get_actual_result(method=method, url=url, response_data_type=content_type, params=params))
for row in range(4, request_method.read_execl.get_row_count() + 1):
# 根据列表是否运行字段 如果字段的值为Y 那么执行当前行号用例
if request_method.read_execl.get_case_if_execute(row=row) == "Y":
def __init__(self, excel_path, sheet_name):
self.element = ReadExcel(excel_path,sheet_name).get_excel_data()
class TaxTestCase(unittest.TestCase):
# 拼接完整的excel路径，然后读取excel数据
wb = ReadExcel(os.path.join(DATA_DIR, "test_cases.xlsx"), "tax")
cases = wb.read_line_data()
@classmethod
def setUpClass(cls):
logging.info(
"==================== 准备开始执行编辑报税接口测试 ====================")
cls.request = HTTPRequest()
cls.db = ExecuteMsql()
@classmethod
def tearDownClass(cls):
logging.info("==================== 编辑报税测试执行完毕 ====================")
cls.request.close()
@data(*cases)
def test_edit_tax(self, case):
# 拼接url
url = conf.get("env", "fscurl") + case.url
self.row = case.case_id + 1
# 获取token
token = get_token(phone=eval(case.token_data)["phone"],
pwd=eval(case.token_data)["code"])
# headers = {"fsp_token": token}
headers = case.request_header.replace("#token", token)
# 发送请求，请求参数为字典类型
response = self.request.request(method=case.method,
url=url,
headers=eval(headers))
# 以下打印内容会显示在html报告中
print()
print("请求地址--> {}".format(url))
print("请求数据--> {}".format(case.request_data))
print("期望结果--> {}".format(case.expected_data))
print("服务器响应数据--> {}".format(response.json()))
# res = response.json()
res1 = response.json()
res = {'code': res1['code'], 'msg': res1['msg']}
try:
self.assertEqual(res, eval(case.expected_data))
except AssertionError as e:
result = "FAIL"
logging.exception(e)
raise e
else:
result = "PASS"
logging.info("预期结果是：{}，实际结果是：{}，测试通过".format(
case.expected_data, res))
finally:
self.wb.write_data(self.row, 11, str(res))
self.wb.write_data(self.row, 12, result)
class RechargeTestCase(unittest.TestCase):
"""充值和提现接口"""
wb = ReadExcel(os.path.join(DATA_DIR, filename), 'recharge')
cases = wb.read_data_line_obj_new()
@classmethod
def setUpClass(cls):
logger.info("用例开始执行")
cls.request = HTTPRequest2()
cls.db = ReadMysqlData()
@classmethod
def tearDownClass(cls):
cls.db.close()
cls.request.close()
logger.info("用例执行完毕")
@data(*cases)
def test_recharge_withdraw(self, case):
# 判断该条测试数据是否有sql语句
if case.check_sql:
s_money = self.db.find_one(case.check_sql)[0]
# 发送请求获取结果
url = conf.get('env', 'url') + case.url
print(case.data)
response = self.request.request(method=case.method,
url=url,
data=eval(case.data))
try:
# 校验预期结果
# 预期的结果case.excepted 实际结果response.json()['code']
self.assertEqual(case.excepted, response.json()['code'])
# 校验结果码
if case.check_sql:
# 执行sql语句，获取余额
e_money = self.db.find_one(case.check_sql)[0]
# 本次充值金额
money = eval(case.data)['amount']
# 判断是充值接口还是取现接口
if case.interface == "充值":
logger.info('充值前金额{}，充值后金额{}，本次充值金额{}'.format(
s_money, e_money, money))
self.assertEqual(e_money - s_money, money)
else:
logger.info('取现前金额{}，取现后金额{}，本次取现金额{}'.format(
s_money, e_money, money))
self.assertEqual(s_money - e_money, money)
except AssertionError as e:
# 测试未通过，输出日志
logger.error(e)
# 在excel用例中写入结果
self.wb.write_data(row=case.case_id + 1, column=10, msg='failed')
self.wb.write_data(row=case.case_id + 1,
column=9,
msg=response.text)
raise e
else:
# 测试通过，输出日志
logger.info('测试用例：{}已通过'.format(case.title))
# 在excel用例中写入结果
self.wb.write_data(row=case.case_id + 1, column=10, msg='pass')
self.wb.write_data(row=case.case_id + 1,
column=9,
msg=response.text)
import unittest
from pip._vendor import requests
from common.read_excel import ReadExcel
from common.send_request import SendRequest
from common.sql_data import SqlData
updateGoodsByType_data=ReadExcel().readExcel(r'../data/updateGoodsByType_api.xlsx','Sheet1')
s=requests.session()
class UpdateGoodsByType(unittest.TestCase):
'''修改商品名称、描述或分类'''
@classmethod
def setUpClass(cls):
for i in range(len(updateGoodsByType_data)):
if updateGoodsByType_data[i]['sql'] != '' and '{virtual_goods_id}' in updateGoodsByType_data[i]['body']:
a=SqlData.themis_data(updateGoodsByType_data[i]['sql'])
updateGoodsByType_data[i]['body']=updateGoodsByType_data[i]['body'].replace('{virtual_goods_id}',''.join('%s' %id for id in a[i]))
if '{virtual_goods_id}' in updateGoodsByType_data[i]['expect_result']:
updateGoodsByType_data[i]['expect_result']=updateGoodsByType_data[i]['expect_result'].replace('{virtual_goods_id}',''.join('%s' %id for id in a[i]))
if '{virtual_goods_id}' in updateGoodsByType_data[i]['msg']:
updateGoodsByType_data[i]['msg']=updateGoodsByType_data[i]['msg'].replace('{virtual_goods_id}',''.join('%s' %id for id in a[i]))
def test_updateGoodsByType1(self):
'''修改商品名称'''
r=SendRequest.sendRequest(s,updateGoodsByType_data[0])
expect_result = updateGoodsByType_data[0]['expect_result'].split(":",1)[1]
msg = updateGoodsByType_data[0]['msg'].split(":",1)[1]
print(r.json())
print(updateGoodsByType_data)
case4：不输入账户和密码，点击登录
case5：输入正确的账户和密码，点击登录
'''
'''testdatas = [
{"user":"******","pwd":"123456.","expect":"result"},
{"user":"******","pwd":"123456","expect":"result"},
{"user":"******","pwd":"","expect":"result"},
{"user":"","pwd":"","expect":"result"},
{"user":"******","pwd":"123456.","expect":"result"}
]'''
#路径不能写死，不然后面有人要调用的时候就找不到这个文件，这个时候就需要引入os模块，一层一层的往上去找到这个文件
propath = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
filepath = os.path.join(propath, "commom",
"datas.xlsx") #join是连接工程路径下的common下的datas
print(filepath)
data = ReadExcel(filepath)
testdatas = data.dict_data()
print(testdatas)
@ddt.ddt
class LoginTestCase(unittest.TestCase, Base):
@classmethod
def setUpClass(cls):
cls.driver = webdriver.Firefox()
cls.login_c = LoginPage(cls.driver)
cls.driver.get(url)
def setUp(self):
self.driver.get(url)
self.is_alert_present()
import unittest
from librarys.ddt import ddt, data
from common.read_excel import ReadExcel
from common.constant import EXCEL_DIR
from common.http_request import request_not_cookie
import os
from common.logger import logger
filename = os.path.join(EXCEL_DIR, "casesliumei.xlsx")
re = ReadExcel(filename, "liumei")
cases = re.read_excel_obj()
@ddt
class LoginTestCase(unittest.TestCase):
@data(*cases)
def test_login_pass(self, cases):
response = request_not_cookie(
method=cases.method,
url="http://test.lemonban.com/futureloan/mvc/api" + cases.api,
data=cases.request)
try:
self.assertEqual(response.json(), cases.expected)
logger.info("预期是：{}".format(cases.expected))
except AssertionError as e:
logger.exception("预期 {} ".format(cases.expected))
logger.exception("实际结果是 {} ".format(response.json()))
raise e
else:
from data.get_data import ReadBaseData
from common.read_excel import ReadExcel
import requests
from data.write_data import WriteExcel
from data.open_excel import just_open
import time
readexcel = ReadExcel(0)
max_row = readexcel.get_max_row()
excel = ReadBaseData()
data = excel.get_all_datas()
for i in range(max_row):
readexcel = ReadBaseData()
params = excel.get_all_data(i)
url = host + params[1]
method = params[0]
data = params[2]
expect = params[3]
is_need = params[4]
cell = params[5]
if is_need == 1:
if method == 'get':
r = requests.get(url, params=data, headers=header)
writeexcel = WriteExcel()
writeexcel.write_excel_xls(cell, str(r.json()))
writeexcel1 = WriteExcel()
writeexcel1.get_key(i)
just_open()
else:
class TestAudit(unittest.TestCase):
excel = ReadExcel(case_path, 'audit')
case_data = excel.read_excel()
http = HanderRequest()
db=HandDB()
@classmethod
def setUpClass(cls):
url = conf.get('env', 'url') + '/member/login'
data = {
"mobile_phone": conf.get('login_data', 'admin_phone'),
"pwd": conf.get('login_data', 'admin_pwd')
}
headers = eval(conf.get('env', 'header'))
response = cls.http.send(url=url, method='post', json=data, headers=headers)
res = response.json()
# 获取member_id
admin_member_id = jsonpath.jsonpath(res, '$..id')[0]
setattr(TestData, 'admin_member_id', str(admin_member_id))
# 获取token类型
token_type = jsonpath.jsonpath(res, '$..token_type')[0]
# 获取token值
token = jsonpath.jsonpath(res, '$..token')[0]
token_data = token_type + ' ' + token
setattr(TestData, 'token_data', token_data)
def setUp(self):
url = conf.get('env', 'url') + '/loan/add'
data = {
"member_id": getattr(TestData, 'admin_member_id'),
"title": "借钱实现财富自由",
"amount": 2000,
"loan_rate": 12.0,
"loan_term": 3,
"loan_date_type": 1,
"bidding_days": 5
}
headers = eval(conf.get('env', 'header'))
headers['Authorization'] = getattr(TestData, 'token_data')
response = self.http.send(url=url, method='post', json=data, headers=headers)
res = response.json()
# 获取项目id
loan_id = jsonpath.jsonpath(res, '$..id')[0]
setattr(TestData, 'loan_id', str(loan_id))
@data(*case_data)
def test_audit(self, case):
pass
# 准备用例数据
url = conf.get('env', 'url') + case['url']
method = case['method']
case['data'] = replace_data(case['data'])
data = eval(case['data'])
expected = eval(case['expected'])
headers = eval(conf.get('env', 'header'))
headers['Authorization'] = getattr(TestData, 'token_data')
row = case['case_id'] + 1
# 发送请求
response = self.http.send(url=url, method=method, json=data, headers=headers)
res = response.json()
# 断言
try:
self.assertEqual(expected['code'], res['code'])
self.assertEqual(expected['msg'], res['msg'])
if case['check_sql']:
sql=replace_data(case['check_sql'])
result_status=self.db.get_one(sql)[0]
self.assertEqual(expected['status'],result_status)
except AssertionError as e:
self.excel.write_excel(row=row, column=8, value='未通过')
my_logger.info('用例--->{}:执行未通过'.format(case['title']))
my_logger.error(e)
print("预期结果：{}".format(expected))
print("实际结果：{}".format(res))
raise e
else:
self.excel.write_excel(row=row, column=8, value='已通过')
my_logger.info('用例--->{}:执行已通过'.format(case['title']))
import random
import unittest
from pip._vendor import requests
from common.read_excel import ReadExcel
from common.send_request import SendRequest
from common.sql_data import SqlData
addProductSku_data = ReadExcel().readExcel(r'../data/addProductSku_api.xlsx',
'Sheet1')
s = requests.session()
class AddProductSku(unittest.TestCase):
'''新增子sku'''
@classmethod
def setUpClass(cls):
for i in range(len(addProductSku_data)):
if addProductSku_data[i][
'sql'] != '' and '{parent_sku}' in addProductSku_data[i][
'body']:
a = SqlData.themis_data(addProductSku_data[i]['sql'])
addProductSku_data[i]['body'] = addProductSku_data[i][
'body'].replace('{parent_sku}',
''.join('%s' % id for id in a[i]))
if '{goods_sku}' in addProductSku_data[i]['body']:
addProductSku_data[i]['body'] = addProductSku_data[i][
'body'].replace('{goods_sku}',
'r' + str(random.randint(1, 10000)))
if '{style_quantity}' in addProductSku_data[i]['body']:
addProductSku_data[i]['body'] = addProductSku_data[i][
'body'].replace('{style_quantity}',
import unittest
from pip._vendor import requests
from common.read_excel import ReadExcel
from common.send_request import SendRequest
from common.sql_data import SqlData
deleteGoods_data=ReadExcel().readExcel(r'../data/deleteGoods_api.xlsx','Sheet1')
s=requests.session()
class DeleteGoods(unittest.TestCase):
@classmethod
def setUpClass(cls):
for i in range(len(deleteGoods_data)):
if deleteGoods_data[i]['sql'] !='' and '{virtual_goods_id}' in deleteGoods_data[i]['body']:
a=SqlData.themis_data(deleteGoods_data[i]['sql'])
deleteGoods_data[i]['body']=deleteGoods_data[i]['body'].replace('{virtual_goods_id}',''.join('%s' %id for id in a[i]))
if '{virtual_goods_id}' in deleteGoods_data[i]['msg']:#替换期望结果中的虚拟id
deleteGoods_data[i]['msg']=(deleteGoods_data[i]['msg'].replace('{virtual_goods_id}',''.join('%s' %id for id in a[i])))
else:
continue
def test_deleteGoods1(self):
'''商品id和token正确'''
r=SendRequest.sendRequest(s,deleteGoods_data[0])
expect_result = deleteGoods_data[0]['expect_result'].split(":",1)[1]
msg = deleteGoods_data[0]['msg'].split(":",1)[1]
self.assertEqual(r.json()['execute_status'], eval(expect_result), msg=r.json())
self.assertEqual(r.json()['message'], eval(msg), msg=r.json())
def test_deleteGoods2(self):
'''商品id和token正确，商品在架'''
import pymysql
from retrying import retry
from common.read_excel import ReadExcel
class SqlData():
# 加载sql,返回数据
@retry(stop_max_attempt_number=5, wait_random_max=1000)
def themis_data(sql):
#连接themis数据库
con = pymysql.Connect(host='123.206.135.211',
port=3306,
user='******',
password='******',
database='themis')
cur = con.cursor()
cur.execute(sql)
con.commit()
return cur.fetchall() #返回查询数据
if __name__ == '__main__':
data = ReadExcel.readExcel(r'../data/ableSale&enableSale_api.xlsx',
'Sheet1')
data_sql = data[0]['sql']
find = SqlData.themis_data(data_sql)
print(find)
class TestRegister(unittest.TestCase):
# 通过类创建excel对象
excel = ReadExcel(data_file_path, "register")
# 读取数据
test_data = excel.read_excel()
#创建DB对象
db = HandleDB()
@data(*test_data) # 进行解包
def test_register(self, test_data_cases):
# 第一步：准备用例数据
# 备注：列表、字典方式存储的，excel读取出来是字符串。数值类型，读取出来是数值类型的，字符串类型，读取出来是字符串类型。
# ①拼接完整的接口地址
url = conf.get_str("env", "url_ip") + test_data_cases["url"]
# ②请求的方法
method = test_data_cases["method"]
# ③请求参数
#判断是否有手机号需要替换
if "#phone#" in test_data_cases["data"]:
#生成一个手机号码
phone = self.random_phone()
#进行替换
test_data_cases["data"] = test_data_cases["data"].replace(
"#phone#", phone) # 替换完后需要接收，不然没有实质的替换
data = eval(test_data_cases["data"])
# ④请求头
headers = eval(conf.get_str("env", "headers"))
# ⑤预期结果
expected = eval(test_data_cases["expected"])
# ⑥该用例在表单中所在行
row = test_data_cases["case_id"] + 1
# 第二步：发送请求到接口，获取实际结果
response = HandleRequest().send(url=url,
method=method,
json=data,
headers=headers)
result = response.json()
# 第三步：比对预期结果和实际结果
try:
self.assertEqual(expected["code"], result["code"])
self.assertEqual(expected["msg"], result["msg"])
if result["msg"] == "OK":
#如果注册成功，去数据库查询当前注册的账号是否存在
sql = "select * from futureloan.member where mobile_phone={}".format(
phone)
#获取数据库中有没有该用户的信息：通过db对象，然后调用count方法
count = self.db.count(sql) #查找的结果
#数据库中返回的数据做断言，判断是否有一条数据
self.assertEqual(1, count)
print("预期结果：{}".format(expected))
print("实际结果：{}".format(result))
except AssertionError as e:
self.excel.write_data(row=row, column=8,
value="未通过") # 可以把列(column)放在配置文件里面
# 记录没有通过的日志
my_log.info("用例：{}------>执行未通过".format(test_data_cases["title"]))
# 在没有通过的时候，使用print会打印在测试报告中
print("预期结果：{}".format(expected))
print("实际结果：{}".format(result))
# 在没有通过的时候，将print输出到日志里面
my_log.info("预期结果：{}".format(expected))
my_log.info("实际结果：{}".format(result))
raise e
else:
self.excel.write_data(row=row, column=8,
value="通过") # 可以把列(column)放在配置文件里面
# 记录通过的日志
my_log.info("用例：{}------>执行通过".format(test_data_cases["title"]))
@staticmethod
def random_phone():
# 生成随机的手机号码
phone = "136"
for i in range(8): # 遍历8次
phone += str(random.randint(0, 9)) # 每次生成转换为字符串，再与phone进行拼接
return phone
@classmethod
#所有用例执行完后，再执行
def tearDownClass(cls):
#关闭数据库的连接和游标对象
cls.db.close()
class DelUserRalationTestCase(unittest.TestCase):
'''删除关联用户'''
excel = ReadExcel(os.path.join(DATA_DIR, 'api_user.xlsx'), 'del_user_relation')
cases = excel.read_data_obj()
http = HttpRequest()
def setUp(self):
data_on = {'user_id': '*userid*', 'token': '*token*', 'relation_user_id': '21625'}
data_1 = eval(myconf.get('data', 'data_login'))
data_modify_pwd = Md5().sign(data_1)
res = self.http.requests(method='post', url=apiURL + '/users/login', data=data_modify_pwd)
data_ = res.json().get('data')
user_token = data_.get('token')
user_id = data_.get('user_id')
data_on['user_id'] = user_id
data_on['token'] = user_token
url2 = apiURL + '/users/user_relation'
res_on = self.http.requests(method='post', url=url2, data=Md5().sign(data_on))
print(res_on.json())
print('------------最先执行-------')
@data(*cases)
def test_case_del_user_relation(self, case):
data_list = {'user_id': '*userid*', 'token': '*token*'}
url = apiURL + case.url
method = case.method
excepted = eval(case.excepted)
row = case.case_id + 1
title = case.title
data_1 = eval(myconf.get('data', 'data_login'))
data_modify_pwd = Md5().sign(data_1)
res = self.http.requests(method=method, url=apiURL + '/users/login', data=data_modify_pwd)
data_ = res.json().get('data')
try:
data_.get('token') and data_.get('user_id')
except AttributeError as e:
print('\033[31m访问登录接口失败，未能获取到userid和token！！')
log.debug('访问获取userid和token的登录接口失败，未能获取到userid和token')
raise e
else:
# 获取userid
user_token = data_.get('token')
# 获取token
user_id = data_.get('user_id')
# 获取关联列表，查询relationid，将测试数据中的relationid替换为查询到的id
data_list['user_id'] = user_id
data_list['token'] = user_token
url2 = apiURL + '/users/relation_list'
res_l = self.http.requests(method='post', url=url2, data=Md5().sign(data_list))
res_list = res_l.json().get('data')
rel_id = res_list[0].get('relation_id')
print('获取到的relationid为', rel_id)
rela_id = eval(case.data).get('relation_id')
if '*' in rela_id:
case.data = case.data.replace(rela_id, str(rel_id))
user1 = eval(case.data).get('user_id')
if '*' in user1:
case.data = case.data.replace(user1, user_id)
import unittest
from pip._vendor import requests
from common.read_excel import ReadExcel
from common.send_request import SendRequest
getCatAttr_data = ReadExcel().readExcel(r'../data/getCatAttr_api.xlsx',
'Sheet1')
s = requests.session()
class GetCatAttr(unittest.TestCase):
'''查询指定分类属性接口'''
def test_getCatAttr1(self):
'''分类id正确，token正确'''
r = SendRequest.sendRequest(s, getCatAttr_data[0])
expect_result = getCatAttr_data[0]['expect_result'].split(":", 1)[1]
msg = getCatAttr_data[0]['msg'].split(":", 1)[1]
self.assertEqual(r.json()['execute_status'],
eval(expect_result),
msg=r.json())
self.assertEqual(r.json()['message'], eval(msg), msg=r.json())
def test_getCatAttr2(self):
'''分类id为空，token正确'''
r = SendRequest.sendRequest(s, getCatAttr_data[1])
expect_result = getCatAttr_data[1]['expect_result'].split(":", 1)[1]
msg = getCatAttr_data[1]['msg'].split(":", 1)[1]
class AuditTestCase(unittest.TestCase):
# 读取用例数据
wb = ReadExcel(os.path.join(DATA_DIR, filename), 'audit')
cases = wb.read_data_line_obj_new()
@classmethod
def setUpClass(cls):
logger.info("用例开始执行")
cls.request = HTTPRequest()
cls.db = readmysql()
@classmethod
def tearDownClass(cls):
cls.db.close()
cls.request.close()
logger.info("用例执行完毕")
@data(*cases)
def test_audit(self, case):
# 准备数据
url = conf.get('env', 'url') + case.url
case.data = replace(case.data)
# 测试用例中有*mloanId*需要替换，用例为标的为不存在
sql = "select max(id) from member;"
if "*loanId*" in case.data:
# 获取数据库中最大的标id进行加一，然后进行替换
memberId = self.db.find_one(sql)[0]
memberId += 1
# 替换
case.data = case.data.replace("*loanId*", str(loanId))
# 发送请求获取结果
response = self.request.request(method=case.method,
url=url,
data=eval(case.data))
code = response.json()['code']
if response.json()['msg'] == "加标成功":
sql = "select id from loan where memberId=#memberId# order by id desc limit 1;"
replace(sql)
loan_id = self.db.find_one(sql)
setattr(ConText, "loan_id", str(loan_id))
# 对比结果
try:
self.assertEqual(str(case.excepted), code)
# 获取加标后标的数量
if case.check_sql:
# 获取加标前的标数量
case.check_sql = replace(case.check_sql)
status = self.db.find_count(case.check_sql)
self.assertEqual(eval(case.data)['status'], status)
except AssertionError as e:
# 测试未通过，输出日志
logger.error(e)
# 在excel用例中写入结果
self.wb.write_data(row=case.case_id + 1,
column=9,
msg=response.text)
self.wb.write_data(row=case.case_id + 1, column=8, msg='failed')
raise e
else:
self.wb.write_data(row=case.case_id + 1,
column=9,
msg=response.text)
# 在excel用例中写入结果
self.wb.write_data(row=case.case_id + 1, column=8, msg='pass')
class AddTestCase(unittest.TestCase):
# 读取用例数据
wb = ReadExcel(os.path.join(DATA_DIR,filename),'add')
cases = wb.read_data_line_obj_new()
@classmethod
def setUpClass(cls):
logger.info("用例开始执行")
cls.request = HTTPRequest()
cls.db = readmysql()
@classmethod
def tearDownClass(cls):
cls.db.close()
cls.request.close()
logger.info("用例执行完毕")
@data(*cases)
def test_add(self,case):
# 准备数据
url = conf.get('env','url')+case.url
case.data = replace(case.data)
# 测试用例中有*memberId*需要替换，用例为标的为不存在
sql = "select max(id) from member;"
if "*memberId*" in case.data:
# 获取数据库中最大的用户id进行加一，然后进行替换
memberId = self.db.find_one(sql)[0]
memberId += 1
# 替换
case.data = case.data.replace("*memberId*",str(memberId))
# 判断该用例是否需要校验sql
if case.check_sql:
case.check_sql = replace(case.check_sql)
# 获取加标前的标数量
s_count = self.db.find_count(case.check_sql)
# 发送请求获取结果
response = self.request.request(method=case.method,url=url,data=eval(case.data))
code = response.json()['code']
# 对比结果
try:
self.assertEqual(str(case.excepted),code)
# 获取加标后标的数量
if case.check_sql:
# 获取加标前的标数量
e_count = self.db.find_count(case.check_sql)
self.assertEqual(s_count+1,e_count)
except AssertionError as e:
# 测试未通过，输出日志
logger.error(e)
# 在excel用例中写入结果
self.wb.write_data(row=case.case_id+1, column=9, msg=response.text)
self.wb.write_data(row=case.case_id+1,column=8,msg='failed')
raise e
else:
self.wb.write_data(row=case.case_id+1, column=9, msg=response.text)
# 在excel用例中写入结果
self.wb.write_data(row=case.case_id+1,column=8,msg='pass')
class GetData():
def __init__(self):
self.read_excel = ReadExcel()
self.dataconfig = DataConfig()
#获取excel行数，case个数
def get_case_lines(self):
return self.read_excel.get_lines()
#获取是否执行
def get_run(self, row):
res = None
col = int(self.dataconfig.is_run())
run = self.read_excel.get_cell_value(row, col)
if run == "yes":
res = True
else:
res = False
return res
#是否携带header
def get_header(self, row):
col = int(self.dataconfig.is_header())
header = self.read_excel.get_cell_value(row, col)
if header != "":
return header
else:
return None
#获取用例名称
def get_case_name(self, row):
col = int(self.dataconfig.is_request_name())
case_name = self.read_excel.get_cell_value(row, col)
return case_name
#获取请求方式
def get_request_method(self, row):
col = int(self.dataconfig.is_request_method())
request_method = self.read_excel.get_cell_value(row, col)
return request_method
#获取url
def get_url(self, row):
col = int(self.dataconfig.is_url())
url = self.read_excel.get_cell_value(row, col)
return url
#获取请求数据
def get_data(self, row):
col = int(self.dataconfig.is_data())
data = self.read_excel.get_cell_value(row, col)
if data == "":
return None
return data
#通过获取关键字拿到data数据
def get_json_data(self, row):
read_json = ReadJson()
data = read_json.get_jsondata(self.get_data(row))
return data
#获取预期结果
def get_expcet(self, row):
col = int(self.dataconfig.is_expect())
expect = self.read_excel.get_cell_value(row, col)
if expect == "":
return None
return expect
# 通过sql获取预期结果
def get_expcet_data_for_mysql(self, row):
op_mysql = OperationMysql()
sql = self.get_expcet(row)
res = op_mysql.search_one(sql)
return res.decode('unicode-escape')
#写入实际结果
def write_result(self, row, value):
col = int(self.dataconfig.is_result())
self.read_excel.write_value(row, col, value)
#获取依赖的数据的key
def get_depend_key(self, row):
col = int(self.dataconfig.is_data_depend())
depend_key = self.read_excel.get_cell_value(row, col)
if depend_key == "":
return None
else:
return depend_key
#判断是否有case依赖
def is_depend(self, row):
col = int(self.dataconfig.is_field_depend())
depend_case_id = self.read_excel.get_cell_value(row, col)
if depend_case_id == "":
return None
else:
return depend_case_id
#获取数据依赖字段
def get_depend_field(self, row):
col = int(self.dataconfig.is_field_depend())
data = self.read_excel.get_cell_value(row, col)
if data == "":
return None
else:
return data
class TestAddLoan(unittest.TestCase):
excel = ReadExcel(datapath, 'add_loan')
addloan_data = excel.read_excel()
http = HanderRequest()
@classmethod
def setUpClass(cls):
cls.db = HandDB()
# admin_phone=conf.get('login_data','admin_phone')
# setattr(TestData,'admin_phone',admin_phone)
# admin_pwd=conf.get('login_data','admin_pwd')
# setattr(TestData, 'admin_pwd', admin_pwd)
pass
@data(*addloan_data)
def test_addloan(self, case):
# 准备用例数据
# 拼接完整的接口地址
url = conf.get('env', 'url') + case['url']
case['data']=replace_data(case['data'])
data = eval(case['data'])
expected = eval(case['expected'])
row = case['case_id']+1
header = eval(conf.get('env', 'header'))
if case['interface'] != '登录':
header['Authorization'] = getattr(TestData,'token_data')
method = case['method']
if case['check_sql']:
sql = case['check_sql'].format(getattr(TestData, 'member_id'))
before_count = self.db.get_count(sql)
# 发送请求
response = self.http.send(url=url, method=method, json=data, headers=header)
res = response.json()
if case['interface']=='登录':
# 获取用户id
member_id=jsonpath.jsonpath(res,'$..id')[0]
setattr(TestData,'member_id',str(member_id))
# 获取token类型
token_type=jsonpath.jsonpath(res,'$..token_type')[0]
# 获取token值
token=jsonpath.jsonpath(res,'$..token')[0]
token_data=token_type+' '+token
setattr(TestData,'token_data',token_data)
# 断言
try:
self.assertEqual(expected['code'], res['code'])
self.assertEqual(expected['msg'], res['msg'])
if case['check_sql']:
sql = case['check_sql'].format(getattr(TestData,'member_id'))
after_count = self.db.get_count(sql)
self.assertEqual(1,after_count-before_count)
except AssertionError as e:
self.excel.write_excel(row=row, column=8, value='未通过')
my_logger.info("用例：{}--->执行未通过".format(case["title"]))
my_logger.error(e)
print("预取结果：{}".format(expected))
print("实际结果：{}".format(res))
raise e
else:
self.excel.write_excel(row=row, column=8, value='已通过')
my_logger.info("用例：{}--->执行已通过".format(case["title"]))
@classmethod
def tearDownClass(cls):
cls.db.close()
