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()