class TestHttpRequest(unittest.TestCase):
def setUp(self):
self.t = DoExcel(pro_path.test_data_path, 'Sheet2') #创建一个实例
@data(*test_data)
def test_api(self, item):
global COOKIES #声明全局变量，必要的时候去更新从cookie的值
logging.info('正在执行第{0}条用例：{1}'.format(item['CaseId'], item['Title']))
logging.info('发起请求的地址是：{0}'.format(item['URL']))
logging.info('发起请求的参数是：{0}'.format(item['Param']))
res = HttpRequest().http_request(item["URL"],
eval(item["Param"]),
item["Method"],
cookies=COOKIES)
#登录请求之后会产生一个cookie
if res.cookies != {}: #如果cookie不为空 就对全局变量进行修改
COOKIES = res.cookies
# 断言
try:
self.assertEqual(item['ExpectedResult'], res.json()['Message'])
TestResult = 'PASS' #存储测试用例的执行结果 通过是PASS 失败是fail
except Exception as e:
logging.error('出错了，错误是：{0}'.format(e))
TestResult = 'FAIL'
raise e
finally:
self.t.write_back(item['CaseId'] + 1, 7, str(
res.json())) #因为Excel里面只能支持传递字符串和整数，所以这里要强制转换一下
self.t.write_back(item['CaseId'] + 1, 8, TestResult)
class TestLogin(unittest.TestCase):
def setUp(self):
self.t = DoExcel(DATA_PATH, "login")
self.logger = MyLog("root")
@data(*test_date)
def test_login(self, item):
self.logger.info("******************************")
self.logger.info("正在执行的用例是 {}".format(item["title"]))
self.logger.info("请求的数据是：{0}".format(item["data"]))
res = HttpRequest().http_request(item["url"], eval(item["data"]),
item["method"], item["type"])
try:
self.assertEqual(item["ExpectResult"], res.json()["message"])
TestResult = "PASS" # 如果不报错，测试通过
except AssertionError as e:
print("接口错误，错误是{}".format(e))
TestResult = "Fail" # 如果报错了，测试不通过
finally: # 不管测试结果是否正确，都把结果写入文件
self.logger.info("*********开始写入结果********")
self.t.write_back(item["case_id"] + 1, 8,
str(res.json()["message"])) # 写入实际结果
self.t.write_back(item["case_id"] + 1, 9, TestResult) # 写入测试结果
self.logger.info("*********结束写入数据********")
# print(res.text)
def tearDown(self):
pass
def test_cases(self, case):
global test_result
url = case['Url']
method = case['Method']
param = case['Param']
case_id = case['CaseId']
module = case['Module']
expected_result = case['ExpectedResult']
Log.info('用例参数为{}'.format(case))
actual_result = HttpRequest().http_request(
url, method, param, getattr(GetData, 'cookie')) # 返回 resp
if actual_result.cookies:
setattr(GetData, 'cookie', actual_result.cookies)
Log.info('第{}条{}模块用例，返回结果{}'.format(case_id, module,
actual_result.text))
try:
self.assertEqual(expected_result, actual_result.json())
test_result = 'Pass'
except Exception as e:
test_result = 'Fail'
Log.error(e)
raise e
finally:
Log.info(
'-----------------------------------------开始写回测试结果-----------------------------------------'
)
DoExcel(project_path.test_cases_path).write_excel(
'recharge', case_id + 1, 8, actual_result.text)
DoExcel(project_path.test_cases_path).write_excel(
'recharge', case_id + 1, 9, test_result)
class TestBayonet(unittest.TestCase):
def setUp(self):
self.BayonetDate = DoExcel(DATA_PATH, "bayonet")
self.logger = MyLog("root")
@data(*Data)
def test_bayonet(self, item):
self.logger.info("***********************")
self.logger.info("正在执行的用例是{}".format(item["title"]))
self.logger.info("请求的数据是：{}".format(item["data"]))
res = requests.post(item["url"],
json=eval(item["data"]),
headers=headers)
self.logger.info("接口返回的结果是{}".format(res.json()))
try:
self.assertEqual(item["ExpectResult"], res.json()["message"])
TestResult = "PASS" # 如果不报错，测试通过
except AssertionError as e:
print("接口错误，错误是{}".format(e))
TestResult = "Fail" # 如果报错了，测试不通过
finally: # 不管测试结果是否正确，都把结果写入文件
self.logger.info("*********开始写入结果********")
self.BayonetDate.write_back(item["case_id"] + 1, 8,
str(res.json()["message"])) # 写入实际结果
self.BayonetDate.write_back(item["case_id"] + 1, 9,
TestResult) # 写入测试结果
self.logger.info("*********结束写入数据********")
# print(res.text)
def tearDown(self):
pass
def test_api(self, item):
passorfail = None
#请求之前完成loanid的替换
if item['data'].find('${loanid}') != -1:
if getattr(GetData, 'loanid') == None:
id = DoMysql.cnn_db(
'select max(id) from loan where memberid=82')[0]
item['data'] = str(item['data']).replace('${loanid}', str(id))
setattr(GetData, 'loanId', id) #利用反射去存储结果
else:
item['data'] = str(item['data']).replace(
'${loanid}', str(getattr(GetData, 'LoanId')))
#判断sql语句
if item['sql'] == None: #没有sql语句时
print('正在执行的用例是：第{}条用例'.format(item['case_id']))
res = HttpRequest().http_request(item['url'], eval(item['data']),
item['http_method'],
getattr(GetData, 'COOKIE'))
else: #有sql语句时
print('正在执行的用例是：第{}条用例'.format(item['case_id']))
sql = eval(item['sql'])['sql']
#http请求前
before_amount = DoMysql.cnn_db(sql)[0]
res = HttpRequest().http_request(item['url'], eval(item['data']),
item['http_method'],
getattr(GetData, 'COOKIE'))
#http请求后
after_amount = DoMysql.cnn_db(sql)[0]
amount = abs(after_amount - before_amount)
if str(amount) == str(eval(item['data'])['amount']):
check_res = '数据库校验正确'
else:
check_res = '数据库校验失败'
DoExcel.write_checkres(testcase_path, item['interface'],
item['case_id'], check_res)
print(res.json())
if res.cookies:
setattr(GetData, 'COOKIE', res.cookies)
try:
self.assertEqual(str(item['excepted']),
res.json()['code']) # 断言，没有断言默认不管对错测试用例都执行通过
passorfail = "成功"
except Exception as e:
print('失败用例{},{}：{}'.format(item['interface'], item['case_id'],
res.json()))
passorfail = "失败"
raise e
finally:
DoExcel.write_back(testcase_path, item['interface'],
item['case_id'], str(res.json()), passorfail)
class TestUserRegister(unittest.TestCase):
excel = DoExcel(case_files, 'userRegister')
cases = excel.get_cases()
@classmethod
def setUpClass(cls):
cls.mysql = DoMysql()
warnings.simplefilter("ignore", ResourceWarning)
@data(*cases)
def test_register(self,case):
data=replace(case.data)
resp=HttpRequests().Wshttps(case.url,data,case.method)
print(resp)
# 断言
try:
self.assertEqual(case.expected, resp)
if case.case_id == 1:
# 将短信验证码保存到Context中
code = CheckSql(self.mysql).query_mvcode(eval(data)['mobile'])
print(code)
setattr(Context, 'code', code)
if case.case_id == 2:
# 判断注册成功后，数据库是否有新增数据
uuid =CheckSql(self.mysql).query_uuid(eval(data)['user_id'])
self.assertIsNotNone(uuid)
self.excel.writeResult(case.case_id + 1, str(resp), 'PASS')
def test_api(self, data_item):
global COOKIES
api_logger.info('正在运行第%d条用例：%s' %
(data_item['id'], data_item['description']))
api_logger.info('测试数据是:%s' % data_item['param'])
res = HttpRequest().http_request(data_item['url'],
eval(data_item['param']),
data_item['http_method'], COOKIES)
# 判断上一个请求有没有COOKIES
if res.cookies:
COOKIES = res.cookies
api_logger.info('测试结果是：%s' % res)
try:
self.assertEqual(str(data_item['ExpectedResult']),
res.json()['code'])
test_result = 'PASS'
except AssertionError as e:
test_result = 'FAIL'
api_logger.error('请求出错了，错误是：%s' % e)
raise e
finally:
# 测试结果写回
DoExcel(file_path.testcase_path).weite_back(
data_item['module'], data_item['id'] + 1,
res.json()['code'], test_result)
class TestRecharge(unittest.TestCase):
do_excel=DoExcel(contants.cases_dir)
cases_recharge=do_excel.read_excel("recharge")
@classmethod
def setUpClass(cls):#继承unittest.TestCase中的方法，并重写
print("这是一个类方法")
cls.request = RequestMethod()#实例化放这里，使用session会话方式
cls.my_logger = logger.get_logger(logger_name="TestRecharge")
@data(*cases_recharge)
def test_recharge(self,case):
self.my_logger.info("开始执行第{}条用例".format(case.case_id))
resp=self.request.request_method(case.method,case.url,case.data)
try:
self.assertEqual(case.expectedresult,resp.json()["code"],"recharge error")
# expectedresult在Excel中是code码，这里只判断返回码
# print(type(case.expectedresult))#在do_excel中已转换expectedresult的数据类型
# print(type(resp.json()["code"]))
self.do_excel.write_back(case.case_id+1,resp.text,"Pass")
self.my_logger.info("充值第{}条用例执行结果：Pass".format(case.case_id))
except AssertionError as e:
self.do_excel.write_back(case.case_id+1, resp.text,"Failed")
self.my_logger.error("充值第{}条用例执行结果：Failed".format(case.case_id))
raise e
@classmethod# 此处不要忘了加标识
def tearDownClass(cls):
cls.request.close()#类执行完毕，关闭session会话
class TestLogin(unittest.TestCase):
excel = DoExcel(case_dir, "login")
cases = excel.get_cases()
def setUp(self):
mylogger.info("前置")
self.request = HttpRequest()
def tearDown(self):
self.request.close()
mylogger.info("后置")
@data(*cases)
def test_login(self, case):
mylogger.info("执行第{0}条用例：{1}".format(case.case_id, case.title))
case.data = replace.replace(case.data)
resp = self.request.request(method=case.method, url=case.url, data=case.data)
try:
self.assertEqual(resp.text, case.expected_response)
self.excel.write_back(case.case_id+1, resp.text, "PASS")
except AssertionError as e:
self.excel.write_back(case.case_id+1, resp.text, "FAIL")
mylogger.error("报错了，{0}".format(e))
raise e
mylogger.info("结束测试第{0}条用例：{1}".format(case.case_id, case.title))
class TestRecharge(unittest.TestCase):
'这是一个充值接口测试类'
do_excel = DoExcel(constant.case_file)
cases_recharge = do_excel.read_data('recharge')
mylog = my_log('recharge')
@classmethod
def setUpClass(cls):
cls.request = Request()
# def setUp(self):
# self.mylog.info('------------------------------开始执行用例--------------------------')
@data(*cases_recharge)
def test_recharge(self, case): # 测试充值
self.mylog.info('开始执行第{}条用例'.format(case.case_id))
resp = self.request.request(case.method, case.url, case.data)
try:
self.assertEqual(case.expected, resp.json()['msg'])
TestResult = 'PASS'
except AssertionError as e:
TestResult = 'FAIL'
raise e
finally:
self.do_excel.write_back(case.case_id + 1, resp.text,
TestResult) # 写回实际结果
self.mylog.info('第{}条用例的执行结果是{}'.format(case.case_id, TestResult))
# def tearDown(self):
# self.mylog.info('------------------------------用例执行完成--------------------------')
@classmethod
def tearDownClass(cls):
cls.request.session.close()
class TestSendMCode(unittest.TestCase):
excel = DoExcel(constants.case_files, 'sendMCode')
cases = excel.get_cases()
@classmethod
def setUpClass(cls):
logger.info('测试前置，连接数据库')
cls.mysql = DoMysql()
warnings.simplefilter('ignore', ResourceWarning)
@classmethod
def tearDownClass(cls):
logger.info('测试后置，关闭数据库')
cls.mysql.close_mysql()
@data(*cases)
def test_SendMCode(self, case):
logger.info("测试用例的标题是{0}".format(case.title))
data = replace(case.data)
logger.info(("替换data中的参数化值，并用data接收，返回的data的值是{0}".format(data)))
resp = HttpRequests().Wshttps(case.url, data, case.method)
try:
self.assertEqual(case.expected, resp)
if case.case_id == 1:
code = CheckSql(self.mysql).query_mvcode(eval(data)['mobile'])
self.assertIsNotNone(code)
self.excel.writeResult(case.case_id + 1, str(resp), 'PASS')
except AssertionError as e:
self.excel.writeResult(case.case_id + 1, str(resp), 'FAIL')
class LoginTest(unittest.TestCase):
do_excel = DoExcel(contains.data_path, 'login')
conf_case = do_excel.get_conf("case", "row")
re = do_excel.get_data(conf_case) # 调用常量，需要先导常量所在文件包，在进行 文件名.常量，调用常量路径
def setUp(self):
pass
logger.warn(
'Enable tracemalloc to get the object allocation traceback')
# warnings.simplefilter('ignore',ResourceWarning)
@data(*re)
def test_login(self, case):
qq = Request().request(case.method, case.url, case.data)
try:
self.assertEqual(case.expected, qq, 'login_error') #将返回结果和期望结果进行匹配
self.do_excel.write_data(case.case_id + 1, qq, 'PASS')
logger.info("第{}条用例执行结果：PASS".format(case.case_id))
except AssertionError as e:
self.do_excel.write_data(case.case_id + 1, qq, 'FAIL')
logger.info("第{}条用例执行结果：FAIL".format(case.case_id))
logger.error(e)
def tearDown(self):
pass
class LoginTest(unittest.TestCase):
do_excel = DoExcel(contants.case_file) # 传入test.xlsx
cases = do_excel.get_data('login') #定位表单
request = Request() #实例化request
def setUp(self):
pass
@data(*cases)
def test_login(self, item): #用一个变量来解释data传递的数据
# 使用封装好的request 来完成请求
logger.info("开始执行第{}用例".format(item.id))
resp = self.request.request(item.method, item.url, item.data)
# 将返回结果和期望结果进行匹配
try:
self.assertEqual(item.expected, resp.text, "login error")
self.do_excel.write_result('login', item.id + 1, resp.text, 'PASS')
logger.info("第{}用例执行结果：PASS".format(item.id))
except AssertionError as e:
self.do_excel.write_result('login', item.id + 1, resp.text, 'FAIL')
logger.error("第{}用例执行结果：FAIL".format(item.id))
raise e
def tearDown(self):
pass
class TestUserRegister(unittest.TestCase):
case_dir = contants.case_dir
do_excel = DoExcel(case_dir, 'userRegister')
cases = do_excel.get_data()
logger = get_logger("register")
@classmethod
def setUpClass(cls):
pass
cls.mysql = MysqlUtil(return_dict= True) # 生成一个数据库对象，返回的是数据字典
cls.uid_list = []
def setUp(self):
pass
@data(*cases)
def test_user_register(self,case):
self.logger.info("开始执行{0}模块的第{1}条用例：{2}".format(case.module, case.case_id, case.title))
if json.loads(case.data)["ip"] == "${ip}":
get_ip()
if json.loads(case.data)["mobile"] == "${mobile}":
check_mobile()
if json.loads(case.data)["verify_code"] == "${verify_code}":
get_code(getattr(context.Context, 'mobile')) # 调用发送验证码的函数，发送验证码并将验证码设置为Context类的一个属性
class LoginTest(unittest.TestCase):
do_excel = DoExcel(constants.case_file) # 读取cases.xlsx
cases = do_excel.get_cases('login') # 指定读取login测试数据
request = Request() # 实例化对象
def setUp(self):
pass
def tearDown(self):
pass
@data(*cases)
def test_login(self, case):
logger.info("开始执行第{0}用例".format(case.id))
# 使用封装好的request 来完成请求
resp = self.request.request(case.method, case.url, case.data)
try:
# 将返回结果和期望结果进行匹配
self.assertEqual(case.expected, resp.text, 'login error')
# 一致就写入Excel的结果为Pass
self.do_excel.write_result('login', case.id + 1, resp.text, 'Pass')
logger.info("第{0}用例执行结果：PASS".format(case.id))
except AssertionError as e:
# 不一致就写入Excel的结果为Fail，并抛出异常
self.do_excel.write_result('login', case.id + 1, resp.text, 'Fail')
logger.error("第{0}用例执行结果：FAIL".format(case.id))
raise e
class APITest(unittest.TestCase):
do_excel = DoExcel(contants.case_file) # 传入cases.xlsx
login_cases = do_excel.read('login') # 一个就够，不需要重复写多个对象
request = Request() # 实例化一个对象
def setUp(self):
pass
@unittest.skip("忽略测试，不要运行") # 暂时不运行此用例
@data(*login_cases)
def test_login(self, case):
print("开始执行第{0}行用例".format(case.case_id))
# 使用分装好的request来完成请求
resp = self.request.request(case.method, case.url, case.data) # 实例对象已移到外面，这里要加self.
# 将返回结果与期望结果对比
try:
self.assertEqual(case.expected, resp.text, 'login error')
# 一致就写入Excel的结果PASS
self.do_excel.write_back(case.case_id+1, resp.text, 'PASS') # 实例对象已放外面，类变量加self.
print("第{0}行用例执行结果：PASS".format(case.case_id))
except AssertionError as e:
self.do_excel.write_back(case.case_id+1, resp.text, 'FAIL') # 实例对象已放外面，类变量加self.调用
print("第{0}行用例执行结果：FAIL".format(case.case_id))
raise e
register_cases = do_excel.read('register') # 增加了一个方法
# mysql = MysqlUtil() # 实例化对象（进行了一次数据库的连接）
# sql = "SELECT MAX(MobilePhone) FROM future.member WHERE MobilePhone LIKE '152%';" # 传一条sql进来
# max = mysql.fetch_one(sql)[0] # 找到最大手机号码, 元组里取第1个值
# print(type(max), max)
@data(*register_cases)
def test_register(self, case):
mysql = MysqlUtil() # 实例化对象（进行了一次数据库的连接）
sql = "SELECT MAX(MobilePhone) FROM future.member WHERE MobilePhone LIKE '152%';" # 传一条sql进来
max = mysql.fetch_one(sql)[0] # 找到最大手机号码, 元组里取第1个值
print("开始执行第{0}行用例".format(case.case_id))
import json
data_dict = json.loads(case.data) # Excel字符串转成字典
if data_dict['mobilephone'] == '${register_mobile}': # 判断是否等于标记
data_dict['mobilephone'] = int(max) + 1 # 将最大手机号码+1 赋值给mobilephone
# 使用封装好的request来完成请求
resp = self.request.request(case.method, case.url, data_dict) # 实例对象已移到外面，这里要加self.
# 将返回结果与期望结果对比
try:
self.assertEqual(case.expected, resp.text, 'register error')
# 一致就写入Excel的结果PASS，并且
self.do_excel.write_back(case.case_id+1, resp.text, 'PASS') # 实例对象已放外面，类变量加self.
print("第{0}行用例执行结果：PASS".format(case.case_id))
except AssertionError as e:
self.do_excel.write_back(case.case_id+1, resp.text, 'FAIL') # 实例对象已放外面，类变量加self.调用
print("第{0}行用例执行结果：FAIL".format(case.case_id))
raise e
def tearDown(self):
pass
class TestInvest(unittest.TestCase):
excel = DoExcel(case_dir, "invest")
cases = excel.get_cases()
@classmethod
def setUpClass(cls):
cls.request = HttpRequest()
cls.mysql = DoMysql()
@classmethod
def tearDownClass(cls):
cls.request.close()
cls.mysql.close()
@data(*cases)
def test_invest(self, case):
case.data = replace.replace(case.data)
resp = self.request.request(method=case.method,
url=case.url,
data=case.data)
try:
self.assertEqual(str(case.expected_response), resp.json()["code"])
self.excel.write_back(case.case_id + 1, resp.text, "PASS")
if resp.json()["msg"] == "加标成功":
sql = "select id from future.loan where memberId = 1231 order by id desc limit 1"
loan_id = self.mysql.fetchone(sql)["id"]
setattr(replace.Context, "loan_id", str(loan_id))
except AssertionError as e:
self.excel.write_back(case.case_id + 1, resp.text, "FAIL")
raise e
class LoginTest(unittest.TestCase):
# 可类里，也可模块外
do_excel = DoExcel(contants.case_file) # 传入cases.xlsx
cases = do_excel.read('login')
request = Request() # 实例化一个对象
# 可类里，也可模块外
def setUp(self):
pass
@data(*cases) # 此处传入数据，so读数据就要从test_login()方法移到方法外面，for case in cases:也需删掉
def test_login(self, case): # 加case接收解包数据
print("开始执行第{0}行用例".format(case.case_id))
# 使用分装好的request来完成请求
resp = self.request.request(case.method, case.url, case.data) # 实例对象已移到外面，这里要加self.
# 将返回结果与期望结果对比
# 当用unittest时,比对用断言，不用if恒等==手动了
try:
self.assertEqual(case.expected, resp.text, 'login error')
# 一致就写入Excel的结果PASS
self.do_excel.write_back(case.case_id+1, resp.text, 'PASS') # 实例对象已放外面，类变量加self.
print("第{0}行用例执行结果：PASS".format(case.case_id))
except AssertionError as e:
self.do_excel.write_back(case.case_id, resp.text, 'FAIL') # 实例对象已放外面，类变量加self.调用
print("第{0}行用例执行结果：FAIL".format(case.case_id))
raise e
def tearDown(self):
pass
class TestLogin(unittest.TestCase):
"""
描述登录接口的类
"""
do_excel = DoExcel(contants.case_file) # 利用.实现上下级，来引入其他目录下的文件
cases = do_excel.read_data('login')
req = RequestMethod() # 实例化Reqeust类的对象
def setUp(self):
pass
@data(*cases)
def test_login(self, case):
resp = self.req.request_method(case.method, case.url,
case.data) # 返回请求结果
logger.info("case.expected:{}".format(case.expected))
try:
self.assertEqual(resp.text, case.expected, "Login Error")
self.do_excel.write_data('login', case.case_id + 1, resp.text,
'PASS')
logger.info("第{0}条用例测试结果：PASS".format(case.case_id))
except AssertionError as e:
self.do_excel.write_data('login', case.case_id + 1, resp.text,
'FAIL')
logger.error("第{0}条用例测试结果：FAIL".format(case.case_id))
raise e
def tearDown(self):
pass
class LoginTest(unittest.TestCase):
do_excel = DoExcel(contants.case_file) # 传入cases.xlsx
cases = do_excel.get_cases('login')
request = Request() # 实例化对象
def setUp(self):
pass
@data(*cases)
def test_login(self,case):
logger.info("开始执行第{0}用例".format(case.id))
# 使用封装好的request 来完成请求
resp = self.request.request(case.method, case.url, case.data)
# 将返回结果和期望结果进行匹配
try:
self.assertEqual(case.expected, resp.text, "login error ")
# 一致就写入Excel的结果为PASS，并且
self.do_excel.write_result('login',case.id + 1, resp.text, 'PASS')
logger.info("第{0}用例执行结果：PASS".format(case.id))
except AssertionError as e:
self.do_excel.write_result('login',case.id + 1, resp.text, 'FAIL')
logger.error("第{0}用例执行结果：FAIL".format(case.id))
raise e
def tearDown(self):
pass
class LoginTest(unittest.TestCase):
do_excel = DoExcel(contants.excel_path)
login_cases = do_excel.read_data("login")
@classmethod
def setUpClass(cls):
cls.request = Request()
def setUp(self):
pass
@data(*login_cases)
def test_login(self, case):
logger.info('开始执行第{0}条用例'.format(case.id))
resp = self.request.request(case.method, case.url, case.data)
try:
self.assertEqual(case.expected, resp.text)
self.do_excel.write_data('login', case.id + 1, resp.text, 'PASS')
logger.info('第{0}条用例执行结果:pass'.format(case.id))
except AssertionError as e:
self.do_excel.write_data('login', case.id + 1, resp.text, 'FAIL')
logger.error('第{0}条用例执行结果:fail'.format(case.id))
raise e
def tearDown(self):
pass
@classmethod
def tearDownClass(cls):
cls.request.session.close()
def test_case(self, sheet_name):
do_excel = DoExcel(contants.case_file) #利用.实现上下级，来引入其他目录下的文件
cases = do_excel.read_data(sheet_name)
req = RequestMethod() #实例化Reqeust类的对象
for case in cases:
resp = req.request_method(case.method, case.url,
case.data) #返回请求结果
print("case.expected:{}".format(case.expected))
if resp.text == case.expected:
do_excel.write_data('login', case.case_id + 1, resp.text,
'PASS')
else:
do_excel.write_data('login', case.case_id + 1, resp.text,
'FAIL')
class TestRegister(unittest.TestCase):
excel = DoExcel(case_dir, "register")
cases = excel.get_cases()
@classmethod
def setUpClass(cls):
cls.request = HttpRequest()
cls.mysql = DoMysql()
@classmethod
def tearDownClass(cls):
cls.request.close()
cls.mysql.close()
@data(*cases)
def test_register(self, case):
if case.data.find("register_mobile"):
sql = "select max(mobilephone) from future.member"
register_mobile = int(
self.mysql.fetchone(sql)["max(mobilephone)"]) + 100
case.data = case.data.replace("register_mobile",
str(register_mobile))
print(case.data)
resp = self.request.request(method=case.method,
url=case.url,
data=case.data)
try:
self.assertEqual(resp.text, case.expected_response)
self.excel.write_back(case.case_id + 1, resp.text, "PASS")
except AssertionError as e:
self.excel.write_back(case.case_id + 1, resp.text, "FAIL")
raise e
class RechargeTest(unittest.TestCase):
do_excel = DoExcel(contants.data_file)
cases = do_excel.get_data('withdraw')
def setUp(self):
pass
@data(*cases)
def test_recharge(self, case):
logger.info('开始执行第{}条用例'.format(case.case_id))
res = request.request(case.method, case.url, case.data)
logger.info(res.json())
try:
self.assertEqual(case.expected, res.json()['code'])
self.do_excel.write_back(case.case_id + 1,
res.json()['code'], 'PASS')
except AssertionError as e:
self.do_excel.write_back(case.case_id + 1,
res.json()['code'], 'Failed')
logger.error('断言错误：{}'.format(e))
raise e
def tearDown(self):
pass
@classmethod
def tearDownClass(cls):
request.session.close() # 关闭request请求
class TestVerifiedUserAuth(unittest.TestCase):
case_dir = contants.case_dir
do_excel = DoExcel(case_dir, 'verifyUserAuth')
cases = do_excel.get_data()
logger = get_logger("auth")
@classmethod
def setUpClass(cls):
pass
cls.mysql = MysqlUtil(return_dict= True) # 生成一个数据库对象，返回的是数据字典
try:
with open(contants.uid_list_dir, 'r') as file:
cls.uid_list = file.readlines()
except FileNotFoundError as e:
cls.logger.error("该文件不存在！！")
def setUp(self):
pass
@data(*cases)
def test_verified_user_auth(self,case):
self.logger.info("开始执行{0}模块的第{1}条用例：{2}".format(case.module, case.case_id, case.title))
if json.loads(case.data)["uid"] == "${uid}":
global count
self.uid = str(self.uid_list[count])[:-1]
count += 1
setattr(context.Context, 'uid', self.uid)
self.logger.info("***********",getattr(context.Context, 'uid'))
if json.loads(case.data)["cre_id"] == "${cre_id}":
get_cre_id()
class RechargeTest(unittest.TestCase):
do_excel = DoExcel(contants.case_file) # 传入cases.xlsx
cases = do_excel.get_cases('recharge')
@classmethod
def setUpClass(cls): # 每个测试类里面去运行的操作放到类方法里面
print("\n这是一个类方法")
cls.request = Request() # 实例化对象
def setUp(self): # 每个测试方法里面去运行的操作放到类方法里面
print("这是一个setUP")
pass
@data(*cases)
def test_recharge(self, case):
print("开始执行第{0}用例".format(case.id))
# 使用封装好的request 来完成请求
resp = self.request.request(case.method, case.url, case.data)
# 将返回结果和期望结果进行匹配
try:
self.assertEqual(case.expected,
resp.json()['code'], "recharge error ")
# 一致就写入Excel的结果为PASS，并且
self.do_excel.write_result('recharge', case.id + 1, resp.text,
'PASS')
print("第{0}用例执行结果：PASS".format(case.id))
except AssertionError as e:
self.do_excel.write_result('recharge', case.id + 1, resp.text,
'FAIL')
print("第{0}用例执行结果：FAIL".format(case.id))
raise e
@classmethod
def tearDownClass(cls):
cls.request.close() # 关闭session
class TestVerifyUserAuth(unittest.TestCase):
excel = DoExcel(case_files, 'verifyUserAuth')
cases = excel.get_cases()
@classmethod
def setUpClass(cls):
logger.info('前置操作，连接数据库')
cls.mysql = DoMysql()
warnings.simplefilter('ignore', ResourceWarning)
@classmethod
def tearDownClass(cls):
cls.mysql.close_mysql()
@data(*cases)
def test_verifyUserAuth(self, case):
logger.info("测试执行，测试用例的名称是{}".format(case.title))
data = replace(case.data)
resp = HttpRequests().Wshttps(case.url, data, case.method)
try:
self.assertEqual(case.expected, resp)
if case.case_id == 1:
code = CheckSql(self.mysql).query_mvcode(eval(data)['mobile'])
setattr(Context, 'code', code)
if case.case_id == 2:
uuid = CheckSql(self.mysql).query_uuid(eval(data)['user_id'])
setattr(Context, 'uuid', str(uuid))
logger.info('测试通过，测试结果回写excel')
self.excel.writeResult(case.case_id + 1, str(resp), 'PASS')
def test_register(self, case):
# 执行测试
# global TestResult
# global token # 声明全局变量
method = case['Method']
url = case['Url']
param = eval(case['Params'])
h = {'token': jianquan()}
# 3.发起测试
my_log.info('----正在测试{}模块第{}条测试用例：{}----'.format(
case['Module'], case['CaseID'], case['Title']))
my_log.info('测试数据是：{}'.format(case))
resp = HttpRequest().http_request(method, url, param=param, headers=h)
try:
self.assertEqual(case['ExpectedResult'], resp.text)
TestResult = 'Pass'
except Exception as e:
TestResult = 'Failed'
my_log.error('注册失败：{}'.format(e))
raise e # 将异常抛出
finally:
# 写回结果
t = DoExcel(case_path, 'login')
t.write_back(case['CaseID'] + 1, 8, resp.text) # 写回实际结果
t.write_back(case['CaseID'] + 1, 9, TestResult) # 写回测试结论
my_log.info('实际结果是：{}'.format(resp.text))
class TestHttpRequest(unittest.TestCase):
def setUp(self):
self.t = DoExcel(project_path.test_data_path,
'test_data') # 操作Excel的实例
# print("开始测试啦")
logger.info("开始执行测试啦")
@data(*test_data)
def test_http_request(self, a):
# print("测试数据是:",a)
# print("目前正在执行第%s条用例"%a[0])
logger.info("测试数据是:{0}".format(a))
logger.info("目前正在执行第%s条用例" % a[0])
global COOKIES
# IP+a[4] ip地址与uri的拼接
res = HttpRequest(IP + a[4], a[5]).http_request(a[3], cookies=COOKIES)
if res.cookies != {}: # 判断长度或者是判断是否为空{}
COOKIES = res.cookies # 只有登录才会产生cookies
# print(res.json())
# 检查数据库
# eval(a[6])
print(a[7]['sql_data'])
print(type(a[7]['sql_data']))
sql_result = DoMysql().do_mysql(a[7]['sql'], (str(a[7]['sql_data']), ))
try:
self.assertEqual(str(sql_result), a[7]['expected'])
check_sql_result = 'PASS'
except AssertionError as e:
check_sql_result = 'FAIL'
raise e
finally:
self.t.write_data(a[0] + 1, 2, str(sql_result), check_sql_result)
try:
self.assertEqual(str(a[6]), res.json()['code'])
result = 'PASS'
# self.t.write_data(a[0]+1,str(res.json()),test_result)
except AssertionError as e:
result = 'Fail'
# self.t.write_data(a[0]+1,str(res.json()),test_result)
raise e # 跟return一样 中断代码
finally: #
self.t.write_data(a[0] + 1, 1, str(res.json()), result)
def tearDown(self):
# print("结束测试了")
logger.info("结束测试了")
class TestApiMethod(unittest.TestCase):
'这是测试接口的类'
do_excel = DoExcel(contants.excel_file) # 传入excel
cases_login = do_excel.read_excel("login")
cases_register = do_excel.read_excel("register")
request = Request()
def setUp(self):
# self.write_register = do_excel.write_excel("register") # 创建一个对象写入
# self.write_register = do_excel.write_excel("login") # 创建一个对象写入
my_log.info("开始执行用例")
def tearDown(self):
my_log.info("用例执行结束")
@data(*cases_register)
def test_register(self, case): # 测试注册
my_log.info("开始执行第{}条用例: {}".format(case.case_id, case.title))
my_log.info('url:{}'.format(case.url))
my_log.info('data:{}'.format(case.data))
my_log.info('method:{}'.format(case.method))
my_log.info('expected:{}'.format(case.expected))
result = self.request.request(case.method, case.url, case.data)
try:
self.assertEqual(case.expected, result.text)
self.do_excel.write_excel(case.case_id + 1, result.text,
"Pass") # 写入测试实际结果
# TestResult = "Pass"
except AssertionError as e:
self.do_excel.write_excel(case.case_id + 1, result.text,
"Failed") # 写入测试实际结果
# TestResult = "Failed"
my_log.error("断言出错了".format(e))
raise e
# finally:
# self.do_excel.write_excel(case.case_id+1, result.text, TestResult) # 写入测试实际结果
# my_log.info('注册的结果：{}'.format(result))
@data(*cases_login)
def test_login(self, case): # 测试登陆
my_log.info("开始执行第{}条用例: {}".format(case.case_id, case.title))
my_log.info('url:{}'.format(case.url))
my_log.info('data:{}'.format(case.data))
my_log.info('method:{}'.format(case.method))
my_log.info('expected:{}'.format(case.expected))
result = self.request.request(case.method, case.url, case.data)
try:
self.assertEqual(case.expected, result.text)
self.do_excel.write_excel(case.case_id + 1, result.text,
"Pass") # 写入测试实际结果
# TestResult = "Pass"
except AssertionError as e:
self.do_excel.write_excel(case.case_id + 1, result.text,
"Failed") # 写入测试实际结果
# TestResult = "Failed"
my_log.error("断言出错了".format(e))
raise e
