class TestRegister(unittest.TestCase):
excel = ReadExcel(data_file_path, "register")
cases = excel.read_data()
http = HandleRequest()
@data(*cases)
def test_register(self, case):
# ------第一步：准备用例数据------------
# 拼接完整的接口地址
url = conf.get_str("env", "url") + case["url"]
# 请求的方法
method = case["method"]
# 请求参数
# 判断是否有有手机号码需要替换
if "#phone#" in case["data"]:
# 生成一个手机号码
phone = self.random_phone()
# 进行替换
case["data"] = case["data"].replace("#phone#", phone)
data = eval(case["data"])
# 请求头
headers = eval(conf.get_str("env", "headers"))
# 预期结果
expected = eval(case["expected"])
# 该用例在表单的中所在行
row = case["case_id"] + 1
# ------第二步：发送请求到接口，获取实际结果--------
response = self.http.send(url=url, method=method, json=data, headers=headers)
result = response.json()
# --------------------以下内容为扩展内容----------------
# 先判断是否注册成功，如果是注册成功
# self.phone = "注册成功的手机号码" # 没有注册成功就设置未None
# ---------------------------------------------------
# -------第三步：比对预期结果和实际结果-----
try:
self.assertEqual(expected["code"], result["code"])
self.assertEqual((expected["msg"]), result["msg"])
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
my_log.info("用例：{}--->执行未通过".format(case["title"]))
print("预取结果：{}".format(expected))
print("实际结果：{}".format(result))
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
my_log.info("用例：{}--->执行通过".format(case["title"]))
@staticmethod
def random_phone():
"""生成随机的手机号码"""
phone = "133"
for i in range(8):
phone += str(random.randint(0, 9))
return phone
class Test_Login(unittest.TestCase):
excel = ReadExcel(case_file, "login")
cases = excel.read_data() #列表==》2个及以上的字典==》1个字典就是一条用例
request = SendRequest()
@data(*cases)
def test001_login(self, case):
#第一步：准备接口请求数据
url = conf1.get("env", "url") + case["url"]
# print(url)
method = case['method']
# eval这个内置函数的作用：执行一个字符串表达式、并且返回执行后的结果
params = eval(case['params'])
# print(params)
auth = HTTPBasicAuth("1000001".encode('utf-8'), "123456")
expected = eval(case['expected']) #用来和实际结果进行对比==》断言
# print(expected)
row = case['case_id'] + 1
# #第二步：发送接口请求
c = SendRequest()
res = self.request.send(method,
api="login",
url=url,
params=params,
auth=auth)
# res = self.request.send(method, api="login", url=url, params=params)
result = res.json()
print(result)
class TestLogin(unittest.TestCase):
excel = ReadExcel(case_file, "login")
cases = excel.read_data()
request = SendRequest()
@data(*cases)
def test_login(self, case):
# 第一步：准备用例数据
url = conf.get("env", "url") + case["url"]
method = case["method"]
data = eval(case["data"])
headers = eval(conf.get("env", "headers"))
expected = eval(case["expected"])
row = case["case_id"] + 1
# 第二步：发送请求，获取结果
response = self.request.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"])
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
log.error("用例：{}，执行未通过".format(case["title"]))
log.exception(e)
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
log.info("用例：{}，执行未通过".format(case["title"]))
class TestUser(unittest.TestCase):
excel = ReadExcel(os.path.join(data_dir, "test_cases.xlsx"),
"username_email")
cases = excel.read_data()
request = SendRequest()
@data(*cases)
def test_user(self, case):
# 准备用例数据
url = conf.get("env", "url") + CaseData.replace_data(case["url"])
data = eval(case["data"])
headers = eval(conf.get("env", "headers"))
method = case["method"]
expected = eval(case["expected"])
row = case["case_id"] + 1
# 发送请求，获取相应结果
reponse = self.request.send(url=url,
method=method,
headers=headers,
params=data)
res = reponse.json()
print("预期结果", expected)
print("实际结果", res)
# 断言
try:
self.assertEqual(res["count"], expected["count"])
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="不通过")
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
class TestMainStream(unittest.TestCase):
excel = ReadExcel(case_file, "main_stream")
cases = excel.read_data()
request = SendRequest()
@data(*cases)
def test_main_stream(self, case):
# 第一步：准备用例数据
url = conf.get("env", "url") + replace_data(case["url"])
method = case["method"]
if case["interface"] == "register":
# 注册接口，则随机生成一个手机号码
CaseDate.mobilephone = self.random_phone()
data = eval(replace_data(case["data"]))
headers = eval(conf.get("env", "headers"))
# 判断是否是登录接口，不是登录接口则需要添加token
if case["interface"] != "login" and case["interface"] != "register":
headers["Authorization"] = getattr(CaseDate, "token_value")
expected = eval(case["expected"])
row = case["case_id"] + 1
# 第二步：发送请求，获取结果
print("请求参数：", data)
response = self.request.send(url=url,
method=method,
json=data,
headers=headers)
res = response.json()
print("预期结果", expected)
print("实际结果", res)
# 发送请求后，判断是否是登陆接口
if case["interface"].lower() == "login":
# 提取用户id保存为类属性
CaseDate.member_id = str(jsonpath.jsonpath(res, "$..id")[0])
token = jsonpath.jsonpath(res, "$..token")[0]
token_type = jsonpath.jsonpath(res, "$..token_type")[0]
# 提取token,保存为类属性
CaseDate.token_value = token_type + " " + token
# 判断是否是加标的用例，如果是的则请求标id
if case["interface"] == "add":
CaseDate.loan_id = str(jsonpath.jsonpath(res, "$..id")[0])
# 第三步：断言（比对预期结果和实际结果）
try:
self.assertEqual(expected["code"], res["code"])
self.assertIn(expected["msg"], res["msg"])
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
log.error("用例：{}，执行未通过".format(case["title"]))
log.exception(e)
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
log.info("用例：{}，执行未通过".format(case["title"]))
def random_phone(self):
phone = "137"
n = random.randint(100000000, 999999999)
phone += str(n)[1:]
return phone
class TestLogin(unittest.TestCase):
excel = ReadExcel(data_path, 'login')
login_data = excel.read_excel()
http = HeadleRequest()
@data(*login_data)
def test_login(self, case):
# 准备测试数据
url = conf.get('env', 'url') + case['url']
expected = eval(case['expected'])
data = eval(case['data'])
row = case['case_id'] + 1
method = case['method']
headers = eval(conf.get('env', 'headers'))
# 发送请求
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'])
except AssertionError as e:
self.excel.write(row=row, column=8, value='未通过')
mylog.info('用例：{}---->执行未通过'.format(case['title']))
print('预期结果:{}'.format(expected))
print('实际结果:{}'.format(res))
raise e
else:
self.excel.write(row=row, column=8, value='通过')
mylog.info('用例：{}---->执行通过'.format(case['title']))
class TestRegister(unittest.TestCase):
excel = ReadExcel(case_file, 'register')
datas = excel.read_data()
request = SendRequest()
@data(*datas)
def test_regiter(self, case):
# 准备测试数据
CaseData.username = self.random_user()
CaseData.email = self.random_email()
url = conf.get('env', 'url') + replace_data(case['url'])
method = case['method']
case['data'] = replace_data(case['data'])
data = eval(case['data'])
expected = eval(case['expected'])
row = case['case_id'] + 1
# 获取结果
response = self.request.send(url=url, method=method, json=data)
res = response.json()
status = response.status_code
# 对预期结果和相应结果进行断言
try:
self.assertEqual(expected['status'], status)
if case['title'] != '注册成功':
if case['method'].lower() == 'get':
self.assertEqual(expected['count'], res['count'])
else:
self.assertIn(expected['msg'], str(res.values()))
except AssertionError as E:
print('预期结果：', expected)
print('实际结果：', status, res)
self.excel.write_data(row=row, column=8, value='不通过')
log.error('{}用例不通过'.format(case['title']))
log.exception(E)
raise E
else:
self.excel.write_data(row=row, column=8, value='通过')
def random_user(self):
self.user = ''.join(
random.sample('0123456789zbcdefghijklmnopqrstuvwxyz', 6))
url = r'http://api.keyou.site:8000/user/{}/count/'.format(self.user)
method = 'get'
response = self.request.send(url=url, method=method)
res = response.json()
if res['count'] == 1:
self.random_user()
return self.user
def random_email(self):
email = self.user + '@163.com'
url = r'http://api.keyou.site:8000/user/{}/count/'.format(email)
method = 'get'
response = self.request.send(url=url, method=method)
res = response.json()
if res['count'] == 1:
self.random_user()
self.random_email()
return email
class Test_Login(unittest.TestCase):
excel = ReadExcel(case_file, "能源管理中心")
cases = excel.read_data() #列表==》2个及以上的字典==》1个字典就是一条用例
request = SendRequest()
token = Token_cls().token()
@data(*cases)
def test001_login(self, case):
#第一步：准备接口请求数据
url = conf1.get("env", "url") + case["url"]
# print(url)
method = case['method']
# eval这个内置函数的作用：执行一个字符串表达式、并且返回执行后的结果
params = eval(case['params']) # eval函数的参数必须为字符串，否则将报错：
# params = case['params']
headers = {"Content-Type": "text/plain", "ID-Token": self.token}
expected = eval(case['expected']) #用来和实际结果进行对比==》断言
classification = case['classification'] #用来和实际结果进行对比==》断言
row = case['case_id'] + 1
# 第二步：发送接口请求
# c = SendRequest()
res = self.request.send(method,
url=url,
params=params,
headers=headers)
# res = self.request.send(method, api="login", url=url, params=params)
result = res.json()
# self.excel.write_data(row=row, column=10, value=str(result))
print(result)
class TESTAdd(unittest.TestCase):
excel = ReadExcel(file_path, "add")
cases = excel.read_data()
request = SendRequest()
@classmethod
def setUpClass(cls):
"""管理员账户登录"""
url = conf.get("env", "url") + "/member/login"
data = {
"mobile_phone": conf.get("test_data", "admin_phone"),
"pwd": conf.get("test_data", "admin_pwd")
}
headers = eval(conf.get("env", "headers"))
response = cls.request.send(url=url,
method="post",
json=data,
headers=headers)
res = response.json()
token = jsonpath.jsonpath(res, "$..token")[0]
token_type = jsonpath.jsonpath(res, "$..token_type")[0]
member_id = jsonpath.jsonpath(res, "$..id")[0]
# 将提取的数据保存到CaseData的属性中
CaseDate.admin_token_value = token_type + " " + token
CaseDate.admin_member_id = member_id
@data(*cases)
def test_add(self, case):
# 第一步:准备数据
url = conf.get("env", "url") + case["url"]
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = getattr(CaseDate, "admin_token_value")
data = eval(replace_data(case["data"]))
expected = eval(case["expected"])
method = case["method"]
row = case["case_id"] + 1
# 第二步：发请求获取实际结果
response = self.request.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"])
# 数据库校验
except AssertionError as e:
print("预期结果：", expected)
print("实际结果：", res)
self.excel.write_data(row=row, column=8, value="未通过")
log.error("用例：{}，执行未通过".format(case["title"]))
log.exception(e)
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
log.info("用例：{}，执行未通过".format(case["title"]))
class TestRegister(unittest.TestCase):
excel = ReadExcel(case_file, "register")
cases = excel.read_data()
request = SendRequest()
db = DB()
def setUp(self):
"""测试用例运行前运行"""
# 随机生成一个用户名，保存
CaseDate.name = self.random_name()
@data(*cases)
def test_register(self, case):
# 第一步：准备用例数据
url = conf.get("env", "url") + case["url"]
method = case["method"]
# 替换用例数据
data = eval(replace_data(case["data"]))
# 替换预期结果中的数据
expected = eval(replace_data(case["expected"]))
row = case["case_id"] + 1
# 第二步：发送请求，获取结果
response = self.request.send(url=url, method=method, json=data)
res = response.json()
try:
self.assert_dict_item(expected, res)
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
log.error("用例：{}，执行未通过".format(case["title"]))
log.exception(e)
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
log.info("用例：{}，执行通过".format(case["title"]))
def assert_dict_item(self, dic1, dic2):
"""
断言dic1中的所有元素都是diac2中的成员，成立返回True,不成立引发断言错误
:param dic1: 字典
:param dic2: 字典
:return:
"""
for item in dic1.items():
if item not in dic2.items():
raise AssertionError("{} items not in {}".format(dic1, dic2))
def random_name(self):
"""随机生成一个用户名"""
print("---name-")
while True:
s1 = random.choice(["a", "b", "c", "d", "e"])
number = random.randint(1, 999999)
name = s1 + str(number)
# 判断数据库中是否存在该用户名，
res = self.db.find_count(
"SELECT * FROM test.auth_user WHERE username='******'".format(
name))
if res == 0:
return name
class TestRegister(unittest.TestCase):
excel = ReadExcel(os.path.join(data_dir,"test_cases.xlsx"),"register")
cases = excel.read_data()
request = SendRequest()
@data(*cases)
def test_register(self,case):
# 准备用例数据
user = self.random_user()
email = self.random_email()
url = conf.get("env","url") +case["url"]
case["data"] = case["data"].replace("@username@",user)
case["data"] = case["data"].replace("@email@",email)
if case["title"] == "注册失败-用户名已注册" or case["title"] == "注册失败-邮箱已注册":
case["data"] = CaseData.replace_data(case["data"])
data = eval(case["data"])
print(data)
headers = eval(conf.get("env","headers"))
method = case["method"]
if case["title"]!="注册成功":
expected = eval(case["expected"])
row = case["case_id"]+1
# 发送请求
response = self.request.send(url=url,json=data,headers=headers,method=method)
res = response.json()
if case["title"] == "注册成功":
CaseData.pass_username = jsonpath.jsonpath(res,"$.username")[0]
CaseData.passemail = email
expected = eval(CaseData.replace_data(case["expected"]))
print("预期结果",expected)
print("实际结果",res)
# 断言
try:
if case["assert"]=="u":
self.assertEqual(res["username"],expected["username"])
elif case["assert"]=="e":
self.assertEqual(res["email"],expected["email"])
elif case["assert"]=="p":
self.assertEqual(res["password"],expected["password"])
elif case["assert"] == "pc":
self.assertEqual(res["password_confirm"], expected["password_confirm"])
elif case["assert"]=="nfe":
self.assertEqual(res["non_field_errors"],expected["non_field_errors"])
except AssertionError as e:
self.excel.write_data(row=row,column=8,value="不通过")
raise e
else:
self.excel.write_data(row=row,column=8,value="通过")
def random_user(self):
username = "".join(random.sample("1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM", 6))
return username
def random_email(self):
email = ("".join(random.sample("1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM", 4))
+ random.choice(("@163.com", "@126.com", "@qq.com")))
return email
class TestInfo(unittest.TestCase):
excel = ReadExcel(case_file, "info")
cases = excel.read_data()
request = SendRequest()
db = DB()
@classmethod
def setUpClass(cls) -> None:
"""进行登录"""
# 1、准备登录的数据
url = conf.get("env", "url") + "/member/login"
data = {
"mobile_phone": conf.get("test_data", "admin_phone"),
"pwd": conf.get("test_data", "admin_pwd")
}
headers = eval(conf.get("env", "headers"))
# 3、发送请求，进行登录
response = cls.request.send(url=url, method="post", json=data, headers=headers)
# 获取返回的数据
res = response.json()
# 3、提取token,保存为类属性
token = jsonpath.jsonpath(res, "$..token")[0]
token_type = jsonpath.jsonpath(res, "$..token_type")[0]
# 将提取到的token设为CaseData类属性
CaseData.admin_token_value = token_type + " " + token
@data(*cases)
def test_info(self, case):
# 第一步，准备用例数据
url = conf.get("env", "url") + case["url"]
method = case["method"]
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = getattr(CaseData, "admin_token_value")
expected = eval(case["expected"])
row = case["case_id"] + 1
# 第二步，发送请求，获取结果
response = self.request.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"])
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
print("预期结果", expected)
print("实际结果", res)
log.error("用例{}执行未通过".format(case["title"]))
log.exception(e)
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
print("预期结果", expected)
print("实际结果", res)
log.error("用例{}执行通过".format(case["title"]))
class TestUpdate(unittest.TestCase):
excel = ReadExcel(case_file, "update")
cases = excel.read_data()
request = SendRequest()
db = DB()
@classmethod
def setUpClass(cls):
# 1、准备登录的数据
url = conf.get("env", "url") + "/member/login"
data = {
"mobile_phone": conf.get("test_data", "phone"),
"pwd": conf.get("test_data", "pwd")
}
headers = eval(conf.get("env", "headers"))
# 3、发送请求，进行登录
response = cls.request.send(url=url, method="post", json=data, headers=headers)
# 获取返回的数据
res = response.json()
# 3、提取token,保存为类属性
token = jsonpath.jsonpath(res, "$..token")[0]
token_type = jsonpath.jsonpath(res, "$..token_type")[0]
# 将提取到的token设为类属性
CaseDate.token_value = token_type + " " + token
# 提取用户的id，保存为类属性
CaseDate.member_id = str(jsonpath.jsonpath(res, "$..id")[0])
@data(*cases)
def test_update(self, case):
# 第一步：准备用例数据
url = conf.get("env", "url") + case["url"]
method = case["method"]
data = eval(replace_data(case["data"]))
# 替换参数中的用户id
headers = eval(conf.get("env", "headers"))
headers["Authorization"] = getattr(CaseDate, "token_value")
# 在请求头中加入setupclass中提取出来的token
expected = eval(case["expected"])
row = case["case_id"] + 1
# 第二步：发送请求，获取结果
print("请求参数为:",data,type(data))
response = self.request.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"])
except AssertionError as e:
print("预期结果：", expected)
print("实际结果：", res)
self.excel.write_data(row=row, column=8, value="未通过")
log.error("用例：{}，执行未通过".format(case["title"]))
log.exception(e)
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
log.info("用例：{}，执行未通过".format(case["title"]))
class TestInvest(unittest.TestCase):
excel = ReadExcel(data_file_path, "invest")
cases = excel.read_data()
http = HandleRequest()
@data(*cases)
def test_invest(self,case):
#----------第一步：准备用例数据------------
url = conf.get_str("env", "url") + case["url"]
#请求参数
case["data"] = replace_data(case["data"])
data = eval(case["data"])
#请求方法
method = case["method"]
#请求头
headers = eval(conf.get_str("env", "headers"))
if case["interface"] != "login":
headers["Authorization"] = getattr(TestData, "token_data")
#添加请求头中的token
#预期结果
expected = eval(case["expected"])
#用例所在行
row = case["case_id"] + 1
#------------第二步：发送请求-------------
res = self.http.send(url=url, json=data, method=method, headers=headers)
result = res.json()
if case["interface"] == "login":
#提取用户id和token
token_type = jsonpath.jsonpath(result, "$..token_type")[0]
token = jsonpath.jsonpath(result, "$..token")[0]
token_data = token_type + " " + token
id = jsonpath.jsonpath(result, "$..id")[0]
setattr(TestData, "token_data", token_data)
setattr(TestData, "member_id", str(id))
elif case["interface"] == "add":
#提取项目id
loan_id = jsonpath.jsonpath(result, "$..id")[0]
setattr(TestData, "loan_id", str(loan_id))
#第三步：对比结果（断言
try:
self.assertEqual(expected["code"], result["code"])
self.assertEqual(expected["msg"], result["msg"])
#判断是否需要sql校验
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
my_log.info("用例：{}--->执行未通过".format(case["title"]))
print("预期结果： {}".format(expected))
print("实际结果： {}".format(result))
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
my_log.info("用例： {}--->执行通过".format(case["title"]))
class TestRegister(unittest.TestCase):
excel = ReadExcel(case_path, 'register')
case_data = excel.read_excel()
http = HandleRequest()
db=Hande_DB()
@data(*case_data)
def test_register(self, case):
# 准备测试数据
# 拼接完整的接口地址
url = conf.get('env', 'url') + '/member/register'
# 请求方法
method = case['method']
if '#phone#' in case['data']:
phone = self.random_phone()
case['data'] = case['data'].replace('#phone#', phone)
data = eval(case['data'])
expected = eval(case['expected'])
headers = eval(conf.get('env', 'headers'))
row = case['case_id'] + 1
# 2、发送请求
response = self.http.send(url=url, method=method, json=data, headers=headers)
res = response.json()
# 3、比对预期结果与实际结果
try:
self.assertEqual(expected['code'], res['code'])
self.assertEqual(expected['msg'], res['msg'])
if case['check_sql']:
print(case['check_sql'],type(case['check_sql']))
sql=case['check_sql'].format(conf.get('env','phone'))
count=self.db.count(sql)
self.assertEqual(count,1)
except AssertionError as e:
self.excel.write_excel(row=row, column=8, value='未通过')
mylog.info('用例：{}----->执行未通过'.format(case['title']))
mylog.error(e)
print("预期结果：{}".format(expected))
print("实际结果：{}".format(res))
raise e
else:
self.excel.write_excel(row=row, column=8, value='已通过')
mylog.info('用例：{}----->执行已通过'.format(case['title']))
@staticmethod
def random_phone():
phone = '13'
for i in range(9):
phone += str(random.randint(0, 9))
return phone
@classmethod
def tearDownClass(cls) :
cls.db.close()
class TestWithdraw(unittest.TestCase):
excel = ReadExcel(data_file_path, "withdraw")
cases = excel.read_data()
http = HandleRequest()
db = HandleDB()
@data(*cases)
def test_withdraw(self, case):
# 第一步：准备测试用例数据
url = conf.get_str("env", "url") + case["url"]
data = eval(replace_data(case["data"]))
method = case["method"]
headers = eval(conf.get_str("env", "headers"))
if case["interface"] != "login":
headers["Authorization"] = getattr(TestData, "token_data")
expected = eval(case["expected"])
row = case["case_id"] + 1
if case["check_sql"]:
sql = replace_data(case["check_sql"])
start_money = self.db.get_one(sql)[0]
res = self.http.send(url=url,
method=method,
json=data,
headers=headers)
result = res.json()
if case["interface"] == "login":
id = jsonpath.jsonpath(result, "$..id")[0]
setattr(TestData, "member_id", str(id))
token_type = jsonpath.jsonpath(result, "$..token_type")[0]
token = jsonpath.jsonpath(result, "$..token")[0]
token_data = token_type + " " + token
setattr(TestData, "token", token)
try:
self.assertEqual(expected["code"], result["code"])
self.assertEqual(expected["msg"], result["msg"])
if case["check_sql"]:
sql = replace_data(case["check_sql"])
end_money = self.db.get_one(sql)[0]
withdraw_money = decimal.Decimal(str(data["amount"]))
my_log.info("取现之前金额为:{}\n取现金额为:{}\n取现之后金额为:{}".format(
start_money, withdraw_money, end_money))
self.assertEqual(withdraw_money, start_money - end_money)
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
my_log.info("用例:{}---->执行未通过".format(case["title"]))
print("预期结果:{}".format(expected))
print("实际结果:{}".format(result))
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
my_log.info("用例:{}---->执行未通过".format(case["title"]))
class TestWithdraw(unittest.TestCase):
excel = ReadExcel(file_path, "withdraw")
cases = excel.read_data()
request = SendRequest()
db = DB()
@data(*cases)
def test_withdraw(self, case):
# 第一步：准备用例数据
url = conf.get("env", "url") + case["url"]
case["data"] = case["data"].replace("#phone#", conf.get("test_data", "phone"))
case["data"] = case["data"].replace("#pwd#", conf.get("test_data", "pwd"))
headers = eval(conf.get("env", "headers"))
# 判断是否是取现接口，取现接口则加上请求头
if case["interface"].lower() == "withdraw":
headers["Authorization"] = self.token_value
case["data"] = case["data"].replace("#member_id#", str(self.member_id))
data = eval(case["data"])
expected = eval(case["expected"])
method = case["method"]
row = case["case_id"] + 1
# 判断是否需要进行sql校验
if case["check_sql"]:
sql = case["check_sql"].format(conf.get("test_data","phone"))
start_money = self.db.find_one(sql)["leave_amount"]
# 第二步：调用接口，获取实际结果
response = self.request.send(url=url, method=method, json=data, headers=headers)
res = response.json()
# 判断是否是登录接口
if case["interface"].lower() == "login":
# 提取用户id保存为类属性
TestWithdraw.member_id = jsonpath.jsonpath(res, "$..id")[0]
token = jsonpath.jsonpath(res, "$..token")[0]
token_type = jsonpath.jsonpath(res, "$..token_type")[0]
# 提取token,保存为类属性
TestWithdraw.token_value = token_type + " " + token
# 第三步：断言（比对预期结果和实际结果）
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
if case["check_sql"]:
sql = case["check_sql"].format(conf.get("test_data","phone"))
end_money = self.db.find_one(sql)["leave_amount"]
# 比对取现金额是否正确
self.assertEqual(Decimal(str(data["amount"])),start_money-end_money)
except AssertionError as e:
print("预期结果：", expected)
print("实际结果：", res)
self.excel.write_data(row=row, column=8, value="未通过")
log.error("用例：{}，执行未通过".format(case["title"]))
log.exception(e)
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
log.info("用例：{}，执行未通过".format(case["title"]))
class TestInvest(unittest.TestCase):
excel = ReadExcel(file_path, "invest")
cases = excel.read_data()
http = HandleRequest()
@data(*cases)
def test_invest(self, case):
# 第一步：准备用例数据
# 获取url
url = conf.get_str("env", "url") + case["url"]
# 获取数据
case["data"] = replace_data(case["data"])
data = eval(case["data"])
# 请求头
headers = eval(conf.get_str("env", "headers"))
if case["interface"] != "login":
headers["Authorization"] = getattr(TestData, "token_data")
# 预期结果
expected = eval(case["expected"])
# 请求方法
method = case["method"]
# 用例所在的行
row = case["case_id"] + 1
# 第二步：发送请求
res = self.http.send(url=url,
method=method,
json=data,
headers=headers)
json_data = res.json()
if case["interface"] == "login":
# 如果是登录的用例，提取对应的token,和用户id,保存为TestData这个类的类属性，用来给后面的用例替换
token_type = jsonpath.jsonpath(json_data, "$..token_type")[0]
token = jsonpath.jsonpath(json_data, "$..token")[0]
token_data = token_type + " " + token
setattr(TestData, "token_data", token_data)
id = jsonpath.jsonpath(json_data, "$..id")[0]
setattr(TestData, "member_id", str(id))
elif case["interface"] == "add":
# 如果是添加项目，则提取项目id
id = jsonpath.jsonpath(json_data, "$..id")[0]
setattr(TestData, "loan_id", str(id))
# 第三步：断言
try:
self.assertEqual(expected["code"], json_data["code"])
self.assertEqual(expected["msg"], json_data["msg"])
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
my_log.info("用例：{}--->执行未通过".format(case["title"]))
print("预取结果：{}".format(expected))
print("实际结果：{}".format(json_data))
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
my_log.info("用例：{}--->执行通过".format(case["title"]))
class TestCaseWithdraw(unittest.TestCase):
readexcel = ReadExcel(filename=os.path.join(DATAPATH,
conf.get('workbook', 'name')),
sheetname=conf.get('workbook', 'sheet04'))
cases = readexcel.read_excel()
send = SendRequest()
headers = eval(conf.get('env', 'headers'))
base_url = conf.get('env', 'url')
connet = Connet()
sql = 'select leave_amount from futureloan.member WHERE mobile_phone = {}'.format(
conf.get('env', 'phone'))
replacedata = ReplaceData()
@data(*cases)
def testcase_withdraw(self, case):
# case_id title method url data expected result chk_sql interface
row = case['case_id'] + 1
method = case['method']
url = self.base_url + case['url']
data = case['data']
data = eval(self.replacedata.replacedata(data))
expected = eval(case['expected'])
chk_sql = case['chk_sql']
if chk_sql:
sql_data_start = self.connet.select_data(sql=self.sql)
leave_amount_start = sql_data_start['leave_amount']
res_info = self.send.sendrequest(method=method,
url=url,
headers=self.headers,
json=data)
res_info = res_info.json()
if case['interface'] == 'login':
print(res_info)
ReplaceData.member_id = jsonpath.jsonpath(res_info, '$..id')[0]
token = jsonpath.jsonpath(res_info, '$..token')[0]
token_type = jsonpath.jsonpath(res_info, '$..token_type')[0]
self.headers['Authorization'] = '{} {}'.format(token_type, token)
try:
print('实际结果:{}'.format(res_info))
print('期望结果:{}'.format(expected))
if chk_sql:
sql_data_end = self.connet.select_data(sql=self.sql)
leave_amount_end = sql_data_end['leave_amount']
self.assertEqual(Decimal(str(data['amount'])),
(leave_amount_start - leave_amount_end))
self.assertEqual(expected['code'], res_info['code'])
self.assertEqual(expected['msg'], res_info['msg'])
self.readexcel.write_excel(row=row, column=8, value='pass')
log.info('{}用例测试通过'.format(case['title']))
except AssertionError as e:
self.readexcel.write_excel(row=row, column=8, value='fail')
log.error('{}用例测试不通过'.format(case['title']))
log.exception(e)
raise e
class TestRegister(unittest.TestCase):
excel = ReadExcel(case_file, "register")
cases = excel.read_data()
request = SendRequest()
db = DB()
@data(*cases)
def test_register(self, case):
# 第一步，准备用例数据
url = conf.get("env", "url") + case["url"]
method = case["method"]
# 生成一个手机号码
phone = self.random_phone()
# 替换用例数据
case["data"] = case["data"].replace("#phone#", phone)
data = eval(case["data"])
headers = eval(conf.get("env", "headers"))
expected = eval(case["expected"])
row = case["case_id"] + 1
# 第二步，发送请求，获取结果
response = self.request.send(url=url,
method=method,
json=data,
headers=headers)
res = response.json()
if case["check_sql"]:
sql = "SELECT mobile_phone FROM futureloan.member WHERE mobile_phone={}".format(
phone)
user = self.db.find_one(sql)["mobile_phone"]
# 第三步，断言比对预期结果和实际结果
try:
self.assertEqual(expected["code"], res["code"])
self.assertEqual(expected["msg"], res["msg"])
if case["check_sql"]:
self.assertEqual(user, phone)
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
log.error("用例{}执行未通过".format(case["title"]))
log.exception(e)
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
log.error("用例{}执行通过".format(case["title"]))
def random_phone(self):
phone = "136"
n = random.randint(100000000, 999999999)
phone += str(n)[1:]
return phone
class TestAdd(unittest.TestCase):
excel = ReadExcel(file_path, "add")
cases = excel.read_data()
http = HandleRequest()
db = HandleDB()
@data(*cases)
def test_add(self, case):
# 第一步：准备用例数据
url = conf.get_str("env", "url") + case["url"]
case["data"] = replace_data(case["data"])
data = eval(case["data"])
headers = eval(conf.get_str("env", "headers"))
if case["interface"] != "login":
headers["Authorization"] = getattr(TestData, "token_data")
expected = eval(case["expected"])
method = case["method"]
row = case["case_id"] + 1
# 第二步：发送请求
if case["check_sql"]:
sql = replace_data(case["check_sql"])
s_loan_num = self.db.count(sql)
res = self.http.send(url=url,
method=method,
json=data,
headers=headers)
result = res.json()
if case["interface"] == "login":
token_type = jsonpath.jsonpath(result, "$..token_type")[0]
token = jsonpath.jsonpath(result, "$..token")[0]
token_data = token_type + " " + token
setattr(TestData, "token_data", token_data)
id = jsonpath.jsonpath(result, "$..id")[0]
setattr(TestData, "admin_member_id", str(id))
# 第三步：比对结果（断言）
try:
self.assertEqual(expected["code"], result["code"])
self.assertEqual(expected["msg"], result["msg"])
if case["check_sql"]:
sql = replace_data(case["check_sql"])
end_loan_num = self.db.count(sql)
self.assertEqual(end_loan_num - s_loan_num, 1)
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
my_log.info("用例:{}---->执行未通过".format(case["title"]))
print("预期结果:{}".format(expected))
print("实际结果:{}".format(result))
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
my_log.info("用例:{}---->执行未通过".format(case["title"]))
class TestAdd(unittest.TestCase):
excel = ReadExcel(data_path, 'add')
add_data = excel.read_excel()
http = HeadleRequest()
@data(*add_data)
def test_add(self, case):
# 准备用例数据
#拼接url
url = conf.get('env', 'url') + case['url']
#获取数据
case['data'] = handle_data(case['data'])
data = eval(case['data'])
#获取请求方法
method = case['method']
# 获取期望结果
expected = eval(case['expected'])
#获取请求头
headers = eval(conf.get('env', 'headers'))
if case['interface'] != 'login':
headers['Authorization'] = getattr(TestData, 'token_data')
# 获取row
row = case['case_id'] + 1
# 发送请求
response = self.http.send(url=url,
method=method,
json=data,
headers=headers)
res = response.json()
if case['interface'] == 'login':
id = jsonpath.jsonpath(res, '$..id')[0]
setattr(TestData, 'admin_member_id', str(id))
token_type = jsonpath.jsonpath(res, '$..token_type')[0]
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'])
except AssertionError as e:
self.excel.write(row=row, column=8, value='未通过')
mylog.info('用例：{}---->执行未通过'.format(case['title']))
print('预期结果：{}'.format(expected))
print('实际结果：{}'.format(res))
raise e
else:
self.excel.write(row=row, column=8, value='通过')
mylog.info('用例：{}---->执行通过'.format(case['title']))
class TestRegister(unittest.TestCase):
excel = ReadExcel(data_path, 'register')
register_data = excel.read_excel()
http = HeadleRequest()
@data(*register_data)
def test_register(self, case):
#准备用例数据
# 获取url
url = conf.get('env', 'url') + case['url']
# 请求方法
method = case['method']
#判断是否有手机号需要替换
if '#phone#' in case['data']:
phone = self.random_phone()
case['data'] = case['data'].replace('#phone#', phone)
data = eval(case['data'])
#期望结果
expected = eval(case['expected'])
#获取请求头
headers = eval(conf.get('env', 'headers'))
#获取用例id
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'])
except AssertionError as e:
self.excel.write(row=row, column=8, value='未通过')
mylog.info('用例:{}---->执行未通过'.format(case['title']))
print('期望结果：{}'.format(expected))
print('实际结果：{}'.format(res))
raise e
else:
self.excel.write(row=row, column=8, value='通过')
mylog.info('用例:{}---->执行通过'.format(case['title']))
@staticmethod
def random_phone():
phone = '136'
for i in range(8):
phone += str(random.randint(0, 9))
return phone
class Testcases(unittest.TestCase):
excel = ReadExcel(case_file, 'testcases')
datas = excel.read_data()
request = SendRequest()
@classmethod
def setUpClass(cls) -> None:
url = conf.get('env', 'url') + '/user/login/'
method = 'post'
data = {
'username': conf.get('test_data', 'user'),
'password': conf.get('test_data', 'pwd')
}
response = cls.request.send(url=url, method=method, json=data)
res = response.json()
CaseData.token = 'JWT ' + jsonpath.jsonpath(res, '$.token')[0]
@data(*datas)
def test_cases(self, case):
# 准备测试数据
url = conf.get('env', 'url') + case['url']
method = case['method']
headers = {'Authorization': CaseData.token}
CaseData.case_name = random_data()
case['data'] = replace_data(case['data'])
data = eval(case['data'])
expected = eval(case['expected'])
row = case['case_id'] + 1
# 获取结果
response = self.request.send(url=url,
method=method,
headers=headers,
json=data)
res = response.json()
status = response.status_code
# 对预期结果和相应结果进行断言
try:
self.assertEqual(expected['status'], status)
if '成功' not in case['title']:
self.assertIn(expected['msg'], str(res.values()))
except AssertionError as E:
print('预期结果：', expected)
print('实际结果：', status, res)
self.excel.write_data(row=row, column=8, value='不通过')
log.error('{}用例不通过'.format(case['title']))
log.exception(E)
raise E
else:
self.excel.write_data(row=row, column=8, value='通过')
class TestLogin(unittest.TestCase):
excel = ReadExcel(case_file, "invest")
cases = excel.read_data()
request = SendRequest()
@data(*cases)
def test_login(self, case):
# 第一步：准备用例数据
url = conf.get("env", "url") + case["url"]
method = case["method"]
case["data"] = replace_data(case["data"])
data = eval(case["data"])
headers = eval(conf.get("env", "headers"))
# 判断是否是登录接口，不是登录接口则需要添加token
if case["interface"] != "login":
headers["Authorization"] = getattr(CaseDate, "token_value")
expected = eval(case["expected"])
row = case["case_id"] + 1
# 第二步：发送请求，获取结果
response = self.request.send(url=url,
method=method,
json=data,
headers=headers)
res = response.json()
# 发送请求后，判断是否是登陆接口
if case["interface"].lower() == "login":
# 提取用户id保存为类属性
CaseDate.member_id = str(jsonpath.jsonpath(res, "$..id")[0])
token = jsonpath.jsonpath(res, "$..token")[0]
token_type = jsonpath.jsonpath(res, "$..token_type")[0]
# 提取token,保存为类属性
CaseDate.token_value = token_type + " " + token
# 判断是否是加标的用例，如果是的则请求标id
if case["interface"] == "add":
CaseDate.loan_id = str(jsonpath.jsonpath(res, "$..id")[0])
# 第三步：断言（比对预期结果和实际结果）
try:
self.assertEqual(expected["code"], res["code"])
# self.assertEqual(expected["msg"], res["msg"])
self.assertIn(expected["msg"], res["msg"])
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
log.error("用例：{}，执行未通过".format(case["title"]))
log.exception(e)
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
log.info("用例：{}，执行未通过".format(case["title"]))
class TestLogin(unittest.TestCase):
excel = ReadExcel(data_file_path, "login")
cases = excel.read_data()
http = HandleRequest()
@data(*cases)
def test_login(self, case):
# ------第一步：准备用例数据------------
# 拼接完整的接口地址
url = conf.get_str("env", "url") + case["url"]
# 请求的方法
method = case["method"]
# 请求参数
data = eval(case["data"])
# 请求头
headers = eval(conf.get_str("env", "headers"))
# 预期结果
expected = eval(case["expected"])
# 该用例在表单的中所在行
row = case["case_id"] + 1
# ------第二步：发送请求到接口，获取实际结果--------
response = self.http.send(url=url,
method=method,
json=data,
headers=headers)
result = response.json()
# -------第三步：比对预期结果和实际结果-----
try:
# 业务码断言
self.assertEqual(expected["code"], result["code"])
# msg断言
self.assertEqual((expected["msg"]), result["msg"])
except AssertionError as e:
# excel中回写结果
self.excel.write_data(row=row, column=8, value="未通过")
# 记录apicases.xlsx日志
my_log.info("用例：{}--->执行未通过".format(case["title"]))
my_log.error(e)
# 报告中打印预期和实际结果
print("预取结果：{}".format(expected))
print("实际结果：{}".format(result))
raise e
else:
# excel中回写结果
self.excel.write_data(row=row, column=8, value="通过")
# 记录日志
my_log.info("用例：{}--->执行通过".format(case["title"]))
class TestLogin(unittest.TestCase):
excel = ReadExcel(case_file, "login")
cases = excel.read_data()
request = SendRequest()
db = DB()
# 读取excel用例数据
@data(*cases) # 进行拆包
def test_login(self, case):
"""登陆的测试用例"""
# 第一步：准备用例数据
url = conf.get("evn", "url") + case["url"]
headers = eval(conf.get("evn", "headers"))
method = case["method"]
# 登陆账号使用配置文件里面预设值的
TestLogin.mobile = eval(conf.get("test_data", "mobile"))
case["data"] = case["data"].replace("#mobile#", str(self.mobile))
TestLogin.password = eval(conf.get("test_data", "password"))
case["data"] = case["data"].replace("#password#", str(self.password))
data = eval(case["data"])
expected = eval(case["expected"])
row = case["case_id"] + 1
#第二步：发送请求，获取结果
response = self.request.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"])
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
log.error("用例：{}，执行未通过".format(case["title"]))
log.exception(e)
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
log.info("用例：{}，执行未通过".format(case["title"]))
class TestInvest(unittest.TestCase):
excel = ReadExcel(case_file, "invest")
cases = excel.read_data()
request = SendRequest()
@data(*cases)
def test_invest(self, case):
# 第一步，准备用例数据
url = conf.get("env", "url") + case["url"]
method = case["method"]
case["data"] = replace_data(case["data"])
data = eval(case["data"])
headers = eval(conf.get("env", "headers"))
if case["interface"] != "login":
headers["Authorization"] = getattr(CaseData, "token_value")
expected = eval(case["expected"])
row = case["case_id"] + 1
# 第二步，发送请求，获取结果
response = self.request.send(url=url,
method=method,
json=data,
headers=headers)
res = response.json()
if case["interface"].lower() == "login":
CaseData.member_id = str(jsonpath.jsonpath(res, "$..id")[0])
token = jsonpath.jsonpath(res, "$..token")[0]
token_type = jsonpath.jsonpath(res, "$..token_type")[0]
CaseData.token_value = token_type + " " + token
if case["interface"] == "add":
CaseData.loan_id = str(jsonpath.jsonpath(res, "$..id")[0])
# 第三步，断言比对预期结果和实际结果
try:
self.assertEqual(expected["code"], res["code"])
# self.assertEqual(expected["msg"], res["msg"])
self.assertIn(expected["msg"], res["msg"])
except AssertionError as e:
self.excel.write_data(row=row, column=8, value="未通过")
log.error("用例{}执行未通过".format(case["title"]))
log.exception(e)
raise e
else:
self.excel.write_data(row=row, column=8, value="通过")
log.error("用例{}执行通过".format(case["title"]))
class Test_Login(unittest.TestCase):
excel = ReadExcel(case_file, "login")
cases = excel.read_data()
request = SendRequests()
@data(*cases) #可变长参数，接收多条用例，因为cases中有多条用例数据，多条字典
def test001_login(self, case):
#第一步：准备接口请求
url = conf.get("env", "url") + case["url"]
print(url)
method = case['method']
print(method)
data = eval(case['data'])
#eval这个内置函数的作用：执行一个字符串表达式，并且返回执行后的结果
headers = eval(conf.get('env', 'headers'))
#从配置文件文件config.ini中取header等常用请求头信息或者接口参数
expected = eval(case['expected'])
#从excel取expected预期结果内容
row = case['case_id'] + 1
#每跑一行，case_id + 1
#第二步，发送接口请求
response = self.request.send(method=method,
url=url,
headers=headers,
data=data)
print(response.json())
result = response.json()
#第三步：接口的断言
try: #期待值和实际结果值对比断言
self.assertEqual(expected['code'], result['code'])
self.assertEqual(expected['msg'], result['msg'])
except Exception as e:
#定义异常，异常如何
self.excel.write_data(row, column=8, value='未通过')
#写入未通过结果
log.error('用例{}执行不通过'.format(case['title']))
#format格式化，把case中的title写入{}中
log.exception(e)
#抛出异常
raise e
#手动触发异常
else: #否则就正常，正常又如何
self.excel.write_data(row=row, column=8, value='通过')
log.info('用例{}执行通过'.format(case['title']))
class LoginPage(BasePage):
# 首页登录按钮
homeLoginBtn = (eleData.read_excel(9, 3))
"""登录页元素：用户名，密码，验证码，登录按钮，错误提示，注册按钮"""
userNameEle = (eleData.read_excel(2, 3))
passWordEle = (eleData.read_excel(3, 3))
verifyImg = (eleData.read_excel(4, 3))
verifyCode = (eleData.read_excel(5, 3))
loginBtn = (eleData.read_excel(6, 3))
errorMessage = (eleData.read_excel(7, 3))
signInBtn = (eleData.read_excel(8, 3))
testLoginData = ReadExcel("elementData.xlsx", "loginData")
def home_login_btn(self):
"""
首页点击登录按钮
:return:
"""
self.click(self.homeLoginBtn)
def login_fun(self, username='******', password='******'):
"""
统一登录函数
:param username: 用户名
:param password: 密码
:param verify: 验证码
:return:
"""
self.input(self.userNameEle, username)
self.input(self.passWordEle, password)
self._verify(self.verifyImg, img='../report/Image/verify/verify.png')
self.input(self.verifyCode, self.ver)
self.sleep(1)
self.click(self.loginBtn)
def get_fail_text(self):
"""
登录失败时提示信息
:return:
"""
info = self.get_value(self.errorMessage)
logger_F.info(f"login failed : {info}")
return info