def test_invest(self, case): # 将期望结果取出 expected = case.expected # 参数化,将取出来的字符串进行参数替换(如果需要的话) data_str = HandleParam.to_param(case.data) # 拼接url url = do_yaml.read_yaml('api', 'url') + case.url # 向接口发起请求 res = self.do_request.send(url=url, method=case.request_method, data=data_str) # 获取的报文转换为字典 result = res.json() msg = case.title success_msg = do_yaml.read_yaml('msg', 'success_result') fail_msg = do_yaml.read_yaml('msg', 'fail_result') row = case.case_id + 1 # assertEqual第三个参数为用例执行失败之后的提示信息 try: self.assertEqual(expected, result['code'], msg=msg) except AssertionError as e: # 将用例执行结果写入到result_col列 do_log.info('{}用例执行有误'.format(case.title)) self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'result_col'), value=fail_msg) do_log.error('具体异常为{}'.format(e)) raise e else: do_log.info('{}用例执行通过'.format(case.title)) self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'result_col'), value=success_msg) # 判断返回报文中是否有token,如果有则将token取出加入到请求头中 if result.get('data'): if result.get('data').get('token_info'): self.do_request.add_headers({"Authorization": \ "Bearer " + result['data']['token_info']['token']}) # 取出load id的第一种方法 # check_sql = case.check_sql # 取出check_sql # if check_sql: # 如果check_sql不为空, 则代表当前用例需要进行数据校验 # check_sql = HandleParam.to_param(check_sql) # 将check_sql进行参数化 # mysql_data = self.do_mysql.run(check_sql) # 执行sql # load_id = mysql_data['id'] # # 动态创建属性的机制, 来解决接口依赖的问题 # setattr(HandleParam, 'loan_id', load_id) # 取出load id的第二种方法 if case.case_id == 2: load_id = result.get('data').get('id') setattr(HandleParam, 'loan_id', load_id)
def create_new_user(reg_name, pwd='12345678', type=1): """ 创建一个新用户 :param reg_name: :param pwd: :param type: :return: """ # 创建session会话对象,用来发起请求 do_request = HandleRequest() # 创建mysql对象 do_mysql = HandleMysql() # 添加公共请求头 do_request.add_headers(do_yaml.read_yaml('api', 'version')) # 注册请求的url register_url = do_yaml.read_yaml('api', 'prefix') + '/member/register' while True: # 随机生成一个未注册的手机号 mobile_phone = do_mysql.create_not_exsited_mobile() # 创建一个请求体参数 data = { 'mobile_phone': mobile_phone, 'pwd': pwd, 'type': type, 'reg_name': reg_name } # 调用注册接口,发起请求 do_request.send(register_url, data=data) # 查询数据库用户ID的sql,同时进行了数据校验 sql = do_yaml.read_yaml('mysql', 'select_user_id_sql') # 查询数据库,获取用户ID result = do_mysql.run(sql, args=[mobile_phone], is_more=False) # 判断是否存在,如果result为None,则用户不存在,if语句为真,用户创建成功,跳出循环 if result: user_id = result['id'] break # 构建用户信息为嵌套字典的字典 user_info = { reg_name: { 'user_id': user_id, 'mobile_phone': mobile_phone, 'pwd': pwd, 'reg_name': reg_name} } # 关闭mysql对象 do_mysql.close() # 关闭session会话对象 do_request.close() return user_info
def __init__(self): # 建立连接 self.conn = pymysql.connect(host=do_yaml.read_yaml('mysql', 'host'), # mysql服务器ip或者域名 user=do_yaml.read_yaml('mysql', 'user'), # 用户名 password=do_yaml.read_yaml('mysql', 'password'), # 密码 db=do_yaml.read_yaml('mysql', 'db'), # 要连接的数据库名 port=do_yaml.read_yaml('mysql', 'port'), # 数据库端口号,默认为3306 charset='utf8', # 数据库编码为utf8,不能写成utf-8 cursorclass=pymysql.cursors.DictCursor # 游标类型设置,使返回数据为字典 ) # 创建游标对象 self.cursor = self.conn.cursor()
def __init__(self, sheetname, filename=None): if filename is None: self.filename = os.path.join( DATAS_DIR, do_yaml.read_yaml('excel', 'data_name')) else: self.filename = filename self.sheetname = sheetname
def setUpClass(cls): cls.do_request = HandleRequest() # 添加请求头 cls.do_request.add_headers(do_yaml.read_yaml('api', 'version')) # 创建数据库处理对象 cls.do_mysql = HandleMysql()
def setUpClass(cls): # 创建session对象 cls.do_request = HandleRequest() # 添加到配置文件并设置公共请求头 cls.do_request.add_headers(do_yaml.read_yaml('api', 'version')) # 创建mysql数据连接,用来做数据校验 cls.do_mysql = HandleMysql()
def is_existed_mobile(self, mobile): ''' 判断生成的手机号是否已经存在 :param mobile: mobile是待查询的手机号 :return: 手机号能查到存在返回True,不存在返回Fales ''' sql = do_yaml.read_yaml('mysql', 'select_user_sql') if self.run(sql, args=[mobile]): return True else: return False
def test_register(self, case): # 回写结果的row row = case.case_id + 1 # 从excel中读取数据,准备请求参数 # 拼接完整的url new_url = do_yaml.read_yaml('api', 'prefix') + case.url # 参数化获取发起请求的用例数据 new_data = Parameterize.to_parameter(case.data) # 对象调用类属性向服务器发起请求 res = self.do_request.send(new_url, data=new_data) # 将响应报文中的json格式数据转换为字典,得到实际结果:响应体 actual_value = res.json() # 从excel中获取excepted excepted_result = case.excepted # 将json格式的字符串转换为字典格式,得到期望值 excepted_result = json.loads(excepted_result, encoding='utf-8') # 获取title msg = case.title # 从配置文件中读取断言结果:成功 success_result = do_yaml.read_yaml('excel', 'success_result') # 从配置文件中读取断言结果:失败 fail_result = do_yaml.read_yaml('excel', 'fail_result') # 比较预期和实际结果 # 捕获异常,回写结果,打印日志,并主动抛出异常 try: # 多字段断言 self.assertEqual(actual_value.get('code'), excepted_result.get('code'), msg=msg) self.assertEqual(actual_value.get('msg'), excepted_result.get('msg'), msg=msg) except AssertionError as e: # 回写断言结果 self.excel.write_result(row, do_yaml.read_yaml('excel', 'result_col'), fail_result) # 将异常内容写入日志 # do_log.error(f'{msg},执行结果为:{fail_result},具体异常为:{e}\n') do_log.error({e}) # 主动抛出异常 raise e else: # 回写断言结果 self.excel.write_result(row, do_yaml.read_yaml('excel', 'result_col'), success_result) # 打印日志 do_log.info(f'{msg},执行结果为:{success_result}') finally: # 将返回的响应体写入excel self.excel.write_result(row, do_yaml.read_yaml('excel', 'actual_col'), res.text)
def create_logger(cls): my_log = logging.getLogger(do_yaml.read_yaml('log', 'log_name')) my_log.setLevel(do_yaml.read_yaml('log', 'logger_level')) # 创建输出格式 formatter = logging.Formatter(do_yaml.read_yaml( 'log', 'log_formatter')) # 创建到控制台的输出渠道 stream = logging.StreamHandler() stream.setLevel(do_yaml.read_yaml('log', 'stream_levle')) stream.setFormatter(formatter) my_log.addHandler(stream) # 创建到文件的输出渠道,文件目录和配置文件中的文件名进行拼接 filer = logging.FileHandler(filename=os.path.join( LOGS_DIR, do_yaml.read_yaml('log', 'logfile_name')), encoding='utf8') filer.setLevel(do_yaml.read_yaml('log', 'logfile_level')) filer.setFormatter(formatter) my_log.addHandler(filer) return my_log
def create_logger(cls): # 创建日志收集器设置等级 logger = logging.getLogger(do_yaml.read_yaml('log', 'log_name')) logger.setLevel(do_yaml.read_yaml('log', 'logger_level')) # 设置输出格式 formatter = logging.Formatter(do_yaml.read_yaml( 'log', 'log_formatter')) # 创建输出到控制台的日志输出渠道对象,设置等级 stream = logging.StreamHandler() stream.setLevel(do_yaml.read_yaml('log', 'stream_levle')) stream.setFormatter(formatter) # 将渠道对象加入到日志收集器 logger.addHandler(stream) # 创建输出到文件的输出渠道对象,设置等级并加入到日志收集器 filer = logging.FileHandler(os.path.join( LOGS_DIR, do_yaml.read_yaml('log', 'logfile_name')), encoding='utf8') filer.setLevel(do_yaml.read_yaml('log', 'logfile_level')) filer.setFormatter(formatter) logger.addHandler(filer) return logger
def __init__(self): # 1 建立连接 # self.conn = pymysql.connect(host='api.lemonban.com', # mysql服务器IP或者域名 # user='******', # 用户名 # password='******', # 密码 # db='futureloan', # 要连接的数据库名 # port=3306, # 数据库端口号,默认为3306,也可以不写 # charset='utf8', # 数据库编码为utf8,不能写为utf-8 # cursorclass=pymysql.cursors.DictCursor # 添加游标类,取结果的时候返回的字典类型;不添加返回元组 # ) self.conn = pymysql.connect( host=do_yaml.read_yaml('mysql', 'host'), # mysql服务器IP或者域名 user=do_yaml.read_yaml('mysql', 'user'), # 用户名 password=do_yaml.read_yaml('mysql', 'password'), # 密码 db=do_yaml.read_yaml('mysql', 'db'), # 要连接的数据库名 port=do_yaml.read_yaml('mysql', 'port'), # 数据库端口号,默认为3306,也可以不写 charset='utf8', # 数据库编码为utf8,不能写为utf-8 cursorclass=pymysql.cursors. DictCursor # 添加游标类,取结果的时候返回的字典类型(结果不唯一的话返回嵌套字典的列表);不添加返回元组 ) # 2.创建游标对象 self.cursor = self.conn.cursor()
def is_existed_mobile(self, mobile): """ 判断手机号是否被注册 :param mobile: 待判断是否注册的手机号 :return: """ # sql = "select * from member where mobile_phone = %s;" sql = do_yaml.read_yaml('mysql', 'select_user_sql') # 已注册(run函数返回数据,即if表达式为真),返回True;查询不到结果(None),返回False if self.run(sql, args=[mobile], is_more=False): return True else: return False
def test_invest(self, case): expected = case.expected # 取出data并进行参数化 case_data = HandleParams.replace_params(case.data) # url url = do_yaml.read_yaml('api', 'url') + case.url # 发起请求 res = self.do_requests.send(url=url, method=case.request_method, data=case_data) # 结果转为字典 result = res.json() msg = case.title success_msg = do_yaml.read_yaml('msg', 'success_result') fail_msg = do_yaml.read_yaml('msg', 'fail_result') # 获取行号 row = case.case_id + 1 try: # assertEqual第三个参数为用例执行失败之后的提示信息 self.assertEqual(expected, result['code'], msg=msg) except AssertionError as e: # 输出日志 do_logs.info("{}用例执行有误".format(msg)) # 写入用例执行结果 self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'result_col'), value=fail_msg) do_logs.error('具体异常为{}'.format(e)) raise e else: do_logs.info('{}用例执行通过'.format(msg)) # 写入用例执行结果 self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'result_col'), value=success_msg) # 执行用例通过后,判断返回报文中有没有token,有的话取出加到请求头中 if 'token_info' in res.text: token = result['data']['token_info']['token'] self.do_requests.add_headers( {"Authorization": "Bearer " + token}) # 加标成功之后取出loan_id,如果用例中有check_sql,则要进行数据校验 check_sql = case.check_sql if check_sql: check_sql = HandleParams.replace_params(check_sql) loan_id = self.do_mysql.run_sql(check_sql) # 创建动态属性的方式来处理接口依赖 setattr(HandleParams, 'loan_id', loan_id['id']) finally: # 将实际结果写入 self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'actual_col'), value=res.text)
def user_init(): # 获取请求头 headers = do_yaml.read_yaml('api', 'version') # 创建请求对象 do_request = HandleRequests() # 添加公共请求头 do_request.add_headers(headers) # url url = 'http://api.lemonban.com/futureloan/member/register' # 用户数据 user_datas = [{ 'mobile_phone': '', 'pwd': '12345678', 'type': 0, 'reg_name': '管理员' }, { 'mobile_phone': '', 'pwd': '12345678', 'type': 1, 'reg_name': '借款人' }, { 'mobile_phone': '', 'pwd': '12345678', 'type': 1, 'reg_name': '投资人' }] write_yaml = HandleYaml(USER_FILE_DIR) # 连接数据库 do_mysql = HandleMysql() user_info = {} # 生成手机号并注册 for user in user_datas: user['mobile_phone'] = do_mysql.create_not_existed_mobile() # 请求注册接口,返回数据转换成字典并存入字典 res = do_request.send(url, data=user).json() # 获取用户id、密码等信息(区域名为昵称,选项名为data里的字段名以及密码) user_info['{}'.format(user['reg_name'])] = res['data'] user_info['{}'.format(user['reg_name'])]['pwd'] = user['pwd'] # 写入用户文件 write_yaml.write_yaml(USER_FILE_DIR, user_info) # 断开数据库 do_mysql.close() # 断开请求 do_request.close()
def test_add(self, case): # 将期望结果取出 expected = case.expected # 参数化,将取出来的字符串进行参数替换(如果需要的话) data_str = HandleParam.to_param(case.data) # 拼接url url = do_yaml.read_yaml('api', 'url') + case.url # 向接口发起请求 res = self.do_request.send(url=url, method=case.request_method, data=data_str) # 获取的报文转换为字典 result = res.json() msg = case.title # 获取用例标题 success_msg = do_yaml.read_yaml('msg', 'success_result') fail_msg = do_yaml.read_yaml('msg', 'fail_result') row = case.case_id + 1 # assertEqual第三个参数为用例执行失败之后的提示信息 try: self.assertEqual(expected, result['code'], msg=msg) except AssertionError as e: # 将用例执行结果写入到result_col列 do_log.info('{}用例执行有误'.format(case.title)) self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'result_col'), value=fail_msg) do_log.error('具体异常为{}'.format(e)) raise e else: do_log.info('{}用例执行通过'.format(case.title)) self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'result_col'), value=success_msg) # 判断返回报文中是否有token,如果有则将token取出加入到请求头中 if 'token_info' in res.text: self.do_request.add_headers({"Authorization": \ "Bearer " + result['data']['token_info']['token']}) finally: # 将响应实际结果写入到actual_col列 self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'actual_col'), value=res.text)
def test_register(self, case): expected = case.expected # 取出data并进行参数化 case_data = HandleParams.replace_params(case.data) # url url = do_yaml.read_yaml('api', 'url') + case.url # 发起请求 res = self.do_requests.send(url=url, method=case.request_method, data=case_data) # 结果转为字典 result = res.json() msg = case.title success_msg = do_yaml.read_yaml('msg', 'success_result') fail_msg = do_yaml.read_yaml('msg', 'fail_result') # 获取行号 row = case.case_id + 1 try: # assertEqual第三个参数为用例执行失败之后的提示信息 self.assertEqual(expected, result['code'], msg=msg) except AssertionError as e: # 输出日志 do_logs.info("{}用例执行有误".format(msg)) # 写入用例执行结果 self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'result_col'), value=fail_msg) do_logs.error('具体异常为{}'.format(e)) raise e else: do_logs.info('{}用例执行通过'.format(msg)) # 写入用例执行结果 self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'result_col'), value=success_msg) finally: # 将实际结果写入 self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'actual_col'), value=res.text)
def test_login(self, case): # 将期望结果取出并转换为字典 expected = json.loads(case.expected, encoding='utf-8') # 参数化,将取出来的字符串进行手机号替换(如果需要的话) data_str = HandleParam.to_param(case.data) # 拼接url url = do_yaml.read_yaml('api', 'url') + case.url # 将此处的功能模块替换为接口请求 res = self.do_request.send(url=url, method=case.request_method, data=data_str ) result = res.json() msg = case.title success_msg = do_yaml.read_yaml('msg', 'success_result') fail_msg = do_yaml.read_yaml('msg', 'fail_result') row = case.case_id + 1 # assertEqual第三个参数为用例执行失败之后的提示信息 try: self.assertEqual(expected['code'], result['code'], msg=msg) self.assertEqual(expected['msg'], result['msg'], msg=msg) except AssertionError as e: # 将用例执行结果写入到result_col列 do_log.info('{}用例执行有误'.format(case.title)) self.excel.write_data(row=row, column=do_yaml.read_yaml('excel', 'result_col'), value=fail_msg) do_log.error('具体异常为{}'.format(e)) raise e else: do_log.info('{}用例执行通过'.format(case.title)) self.excel.write_data(row=row, column=do_yaml.read_yaml('excel', 'result_col'), value=success_msg) finally: # 将响应实际结果写入到actual_col列 self.excel.write_data(row=row, column=do_yaml.read_yaml('excel', 'actual_col'), value=res.text )
def handle_logger(cls): # 创建一个日志收集器 # my_log = logging.getLogger('my_log') my_log = logging.getLogger(do_yaml.read_yaml('log', 'log_name')) # 设置收集等级 # my_log.setLevel('DEBUG') my_log.setLevel(do_yaml.read_yaml('log', 'in_level')) # 设置输出格式 # formater = logging.Formatter('%(asctime)s - [%(filename)s-->line:%(lineno)d] - %(levelname)s: %(message)s') formater = logging.Formatter( do_yaml.read_yaml('log', 'formater_content')) # 输出到控制台 sh = logging.StreamHandler() # 设置输出等级 # sh.setLevel("WARNING") sh.setLevel(do_yaml.read_yaml('log', 'out_level')) # 将输出格式设置到控制台 sh.setFormatter(formater) # 将输出终端添加到收集器 my_log.addHandler(sh) # 输出到日志文件 # fh = logging.FileHandler('log_1106.log', encoding='utf8') # fh = logging.FileHandler(do_yaml.read_yaml('log', 'log_file'), encoding='utf8') fh = logging.FileHandler(os.path.join( LOGS_DIR, do_yaml.read_yaml('log', 'log_file')), encoding='utf8') # 设置输出等级 # fh.setLevel("WARNING") fh.setLevel(do_yaml.read_yaml('log', 'out_level')) # 将输出格式设置到日志文件 fh.setFormatter(formater) # 将输出终端添加到收集器 my_log.addHandler(fh) # 返回收集器 return my_log
def setUpClass(cls): cls.do_request = HandleRequest() # 添加请求头 cls.do_request.add_headers(do_yaml.read_yaml('api', 'version'))
def setUpClass(cls): cls.do_requests = HandleRequests() cls.do_requests.add_headers(do_yaml.read_yaml('api', 'version'))
def to_parameter(cls, data): # 使用正则进行匹配得到包含未注册手机号的data if re.search(cls.not_existed_tel_pattern, data): # 创建数据库连接及游标对象 do_mysql = HandleMysql() # 匹配得到含有未注册手机号的data data = re.sub(cls.not_existed_tel_pattern, do_mysql.create_not_exsited_mobile(), data) # 关闭数据库游标对象、连接 do_mysql.close() # 已存在的手机号:投资人手机号 if re.search(cls.existed_tel_pattern, data): # 匹配得到含有已存在的手机号的data data = re.sub( cls.existed_tel_pattern, cls.do_yaml_user.read_yaml('investor', 'mobile_phone'), data) # 已存在手机号的密码:投资人密码 if re.search(cls.existed_pwd_pattern, data): # 匹配得到含有已存在手机号的密码的data data = re.sub(cls.existed_pwd_pattern, cls.do_yaml_user.read_yaml('investor', 'pwd'), data) # 会员ID:投资人ID if re.search(cls.existed_investor_id_pattern, data): # 匹配得到含有投资人会员ID的data data = re.sub( cls.existed_investor_id_pattern, str(cls.do_yaml_user.read_yaml('investor', 'user_id')), data) # 不存在的投资人ID if re.search(cls.not_existed_id_pattern, data): # 创建数据库连接及游标对象 do_mysql = HandleMysql() # 配置文件中获取sql # 这里也可以不把sql语句写入配置文件,直接将sql语句写在下面 sql = do_yaml.read_yaml('mysql', 'select_user_max_id_sql') # 运行sql,得到一个字典 res_max = do_mysql.run(sql, is_more=False) # 获取字典的值,转换为字符串,将原data进行参数化 data = re.sub(cls.not_existed_id_pattern, str(res_max.get('max(id)') + 1), data) # 关闭数据库游标对象、连接 do_mysql.close() # 借款人ID # 正则匹配:查找 if re.search(cls.existed_borrower_id_pattern, data): data = re.sub( cls.existed_borrower_id_pattern, str(cls.do_yaml_user.read_yaml('borrower', 'user_id')), data) # 借款人电话 if re.search(cls.existed_borrower_tel_pattern, data): data = re.sub( cls.existed_borrower_tel_pattern, cls.do_yaml_user.read_yaml('borrower', 'mobile_phone'), data) # 借款人密码 if re.search(cls.existed_borrower_pwd_pattern, data): data = re.sub(cls.existed_borrower_pwd_pattern, cls.do_yaml_user.read_yaml('borrower', 'pwd'), data) # 管理员电话 if re.search(cls.existed_admin_tel_pattern, data): data = re.sub(cls.existed_admin_tel_pattern, cls.do_yaml_user.read_yaml('admin', 'mobile_phone'), data) # 管理员密码 if re.search(cls.existed_admin_pwd_pattern, data): data = re.sub(cls.existed_admin_pwd_pattern, cls.do_yaml_user.read_yaml('admin', 'pwd'), data) # loan_id if re.search(cls.loan_id_pattern, data): loan_id = getattr(Parameterize, 'loan_id') data = re.sub(cls.loan_id_pattern, str(loan_id), data) # 不存在的loan_id if re.search(cls.not_existed_loan_id_pattern, data): # 创建数据库连接及游标对象 do_mysql = HandleMysql() sql = "select id from loan order by id desc limit 0,1;" # 运行sql,得到一个字典 res_max = do_mysql.run(sql, is_more=False) # 获取字典的值,转换为字符串,将原data进行参数化 data = re.sub(cls.not_existed_loan_id_pattern, str(res_max.get('id') + 1), data) # 关闭数据库游标对象、连接 do_mysql.close() return data
def test_recharge(self, case): # 回写结果的row row = case.case_id + 1 # 从excel中读取数据,准备请求参数 # 拼接完整的url new_url = do_yaml.read_yaml('api', 'prefix') + case.url # 参数化获取发起请求的用例数据 new_data = Parameterize.to_parameter(case.data) # 获取充值前的账户金额 # 根据excel中sql语句是否存在来判断是否获取充值前金额进行数据校验 if case.check_sql: # 将sql语句参数化 sql = Parameterize.to_parameter(case.check_sql) # 执行查询语句,在数据库中查询得到数据字典 res_dict = self.do_mysql.run(sql, is_more=False) # 取得充值前账户金额,转换为float # global amount_before amount_before = float(res_dict['leave_amount']) # 保留2位小数 amount_before = round(amount_before, 2) # 对象调用类属性向服务器发起请求 res = self.do_request.send(new_url, data=new_data) # 将响应报文中的json格式数据(响应体)转换为字典 actual_value = res.json() # # 获取token(也可以在发送请求后通过case_id 来判断登录用例从而获取token) # if case.case_id == 2: # token_headers = {'Authorization': 'Bearer ' + actual_value['data']['token_info']['token']} # self.do_request.add_headers(token_headers) # 从excel中获取excepted excepted_result = case.excepted # 获取title msg = case.title # 从配置文件中读取断言结果:成功 success_result = do_yaml.read_yaml('excel', 'success_result') # 从配置文件中读取断言结果:失败 fail_result = do_yaml.read_yaml('excel', 'fail_result') # 比较预期和实际结果 # 捕获异常,回写结果,打印日志,并主动抛出异常 try: self.assertEqual(actual_value.get('code'), excepted_result, msg=msg) # 如果充值成功,则获取充值成功后的金额(反向用例没有做数据校验) if case.check_sql: # # 将sql语句参数化 # sql = Parameterize.to_parameter(case.check_sql) # 在数据库中查询得到数据字典 res_dict = self.do_mysql.run(sql, is_more=False) # 取得充值后账户金额,取2位 amount_after = round(float(res_dict['leave_amount']), 2) # 进行断言 amount_real = json.loads(new_data) self.assertEqual(round((amount_after - amount_before), 2), amount_real.get('amount')) except AssertionError as e: # 回写断言结果 self.excel.write_result(row, do_yaml.read_yaml('excel', 'result_col'), fail_result) # 将异常内容写入日志 # do_log.error(f'{msg},执行结果为:{fail_result},具体异常为:{e}\n') do_log.error({e}) # 主动抛出异常 raise e else: # 获取token(也可以在发送请求后通过case_id 来判断登录用例从而获取token) if actual_value.get('data'): if actual_value.get('data').get('token_info'): token_headers = {'Authorization': 'Bearer ' + actual_value['data']['token_info']['token']} self.do_request.add_headers(token_headers) # 回写断言结果 self.excel.write_result(row, do_yaml.read_yaml('excel', 'result_col'), success_result) # 打印日志 do_log.info(f'{msg},执行结果为:{success_result}') finally: # 将返回的响应体写入excel self.excel.write_result(row, do_yaml.read_yaml('excel', 'actual_col'), res.text)
def test_invest(self, case): # 回写结果的row row = case.case_id + 1 # 从excel中读取数据,准备请求参数 # 拼接完整的url new_url = do_yaml.read_yaml('api', 'prefix') + case.url # 参数化获取发起请求的用例数据 new_data = Parameterize.to_parameter(case.data) # 对象调用类属性向服务器发起请求 res = self.do_request.send(new_url, method=case.method, data=new_data) # 将响应报文中的json格式数据(响应体)转换为字典 actual_value = res.json() # 获取标ID # # 获取token # if case.case_id == 2: # token_headers = {'Authorization': 'Bearer ' + actual_value['data']['token_info']['token']} # self.do_request.add_headers(token_headers) # 从excel中获取excepted excepted_result = case.excepted # 获取title msg = case.title # 从配置文件中读取断言结果:成功 success_result = do_yaml.read_yaml('excel', 'success_result') # 从配置文件中读取断言结果:失败 fail_result = do_yaml.read_yaml('excel', 'fail_result') # 比较预期和实际结果 # 捕获异常,回写结果,打印日志,并主动抛出异常 try: self.assertEqual(actual_value.get('code'), excepted_result, msg=msg) except AssertionError as e: # 回写断言结果 self.excel.write_result(row, do_yaml.read_yaml('excel', 'result_col'), fail_result) # 将异常内容写入日志 # do_log.error(f'{msg},执行结果为:{fail_result},具体异常为:{e}\n') do_log.error({e}) # 主动抛出异常 raise e else: # 获取token(也可以在发送请求后通过case_id 来判断登录用例从而获取token) # 也可以使用成员运算:if 'token' in res.text: if actual_value.get('data'): if actual_value.get('data').get('token_info'): token_headers = {'Authorization': 'Bearer ' + actual_value['data']['token_info']['token']} self.do_request.add_headers(token_headers) # 获取loan_id (更方便的是直接从响应报文中获取loan_id) case_sql = case.case_sql if case_sql: # 也可以使用成员运算来判断 if 'loan_id_sql' in case_sql: case_sql = json.loads(case_sql, encoding='utf8').get('loan_id_sql') # 借款人ID参数化 case_sql = Parameterize.to_parameter(case_sql) # 查询数据库中该借款人对应的最新的loan_id loan_id_dict = self.do_mysql.run(case_sql, is_more=False) # 从结果字典中取loan_id loan_id = loan_id_dict.get('id') # 反射机制动态设置类属性,然后进行参数化,使得之后的用例可以取得loan_id(接口依赖) setattr(Parameterize, 'loan_id', loan_id) # 回写断言结果 self.excel.write_result(row, do_yaml.read_yaml('excel', 'result_col'), success_result) # 打印日志 do_log.info(f'{msg},执行结果为:{success_result}') finally: # 将返回的响应体写入excel self.excel.write_result(row, do_yaml.read_yaml('excel', 'actual_col'), res.text)
def test_recharge(self, case): # 回写结果的row row = case.case_id + 1 # 从excel中读取数据,准备请求参数 # 拼接完整的url new_url = do_yaml.read_yaml('api', 'prefix') + case.url # 参数化获取发起请求的用例数据 new_data = Parameterize.to_parameter(case.data) # 对象调用类属性向服务器发起请求 res = self.do_request.send(new_url, data=new_data) # 将响应报文中的json格式数据(响应体)转换为字典 actual_value = res.json() # # 获取token # if case.case_id == 2: # token_headers = {'Authorization': 'Bearer ' + actual_value['data']['token_info']['token']} # self.do_request.add_headers(token_headers) # 从excel中获取excepted excepted_result = case.excepted # 获取title msg = case.title # 从配置文件中读取断言结果:成功 success_result = do_yaml.read_yaml('excel', 'success_result') # 从配置文件中读取断言结果:失败 fail_result = do_yaml.read_yaml('excel', 'fail_result') # 比较预期和实际结果 # 捕获异常,回写结果,打印日志,并主动抛出异常 try: self.assertEqual(actual_value.get('code'), excepted_result, msg=msg) except AssertionError as e: # 回写断言结果 self.excel.write_result(row, do_yaml.read_yaml('excel', 'result_col'), fail_result) # 将异常内容写入日志 # do_log.error(f'{msg},执行结果为:{fail_result},具体异常为:{e}\n') do_log.error({e}) # 主动抛出异常 raise e else: # 获取token(也可以在发送请求后通过case_id 来判断登录用例从而获取token) if actual_value.get('data'): if actual_value.get('data').get('token_info'): token_headers = { 'Authorization': 'Bearer ' + actual_value['data']['token_info']['token'] } self.do_request.add_headers(token_headers) # 回写断言结果 self.excel.write_result(row, do_yaml.read_yaml('excel', 'result_col'), success_result) # 打印日志 do_log.info(f'{msg},执行结果为:{success_result}') finally: # 将返回的响应体写入excel self.excel.write_result(row, do_yaml.read_yaml('excel', 'actual_col'), res.text)
# 判断返回报文中是否有token,如果有则将token取出加入到请求头中 if result.get('data'): if result.get('data').get('token_info'): self.do_request.add_headers({"Authorization": \ "Bearer " + result['data']['token_info']['token']}) # 取出load id的第一种方法 # check_sql = case.check_sql # 取出check_sql # if check_sql: # 如果check_sql不为空, 则代表当前用例需要进行数据校验 # check_sql = HandleParam.to_param(check_sql) # 将check_sql进行参数化 # mysql_data = self.do_mysql.run(check_sql) # 执行sql # load_id = mysql_data['id'] # # 动态创建属性的机制, 来解决接口依赖的问题 # setattr(HandleParam, 'loan_id', load_id) # 取出load id的第二种方法 if case.case_id == 2: load_id = result.get('data').get('id') setattr(HandleParam, 'loan_id', load_id) finally: # 将响应实际结果写入到actual_col列 self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'actual_col'), value=res.text) if __name__ == "__main__": red = TestInvest()
if not os.path.exists(USER_INFO_DIR): generate_user_yaml() # # 创建测试套件对象,导入用到的unittest的TestSuite # suite = unittest.TestSuite() # # 将测试用例添加到测试套件中: # # 分为四种方法,使用ddt后这里使用将测试模块加入到测试套件中(导入测试用例类所在的模块) # loader = unittest.TestLoader() # suite.addTest(loader.loadTestsFromModule(test_01_register)) # suite.addTest(loader.loadTestsFromModule(test_02_login)) # 创建目录测试套件对象,使用unittest.defaultTestLoader.discover() suite = unittest.defaultTestLoader.discover(CASES_DIR) # 创建测试运行程序 # runner = unittest.TextTestRunner() # 也可以生成测试报告,将HTMLTestRunnerNew.py放入python安装目录--lib下,并在该模块导入 report_name = do_yaml.read_yaml('report', 'report_name') + '_' \ + datetime.strftime(datetime.now(), '%Y%m%d%H%M%S') report_name = os.path.join(REPORTS_DIR, report_name) with open(report_name + '.html', 'wb') as f: runner = HTMLTestRunner(stream=f, verbosity=2, title=do_yaml.read_yaml('report', 'report_title'), description=do_yaml.read_yaml('report', 'report_description'), tester=do_yaml.read_yaml('report', 'report_tester')) # 将测试套件添加到测试运行程序 runner.run(suite)
def setUpClass(cls): # 创建session对象 cls.do_request = HandleRequest() # 设置公共请求头并添加到配置文件 cls.do_request.add_headers(do_yaml.read_yaml('api', 'version'))
def test_recharge(self, case): expected = case.expected # 取出data并进行参数化 case_data = HandleParams.replace_params(case.data) # url url = do_yaml.read_yaml('api', 'url') + case.url # 充值前,去数据库获取充值前金额 check_sql = case.check_sql if check_sql: check_sql = HandleParams.replace_params(check_sql) mysql_data = self.do_mysql.run_sql(check_sql) old_amount = round(float(mysql_data['leave_amount']), 2) # 取出当前金额,保留两位小数 # 发起请求 res = self.do_requests.send(url=url, method=case.request_method, data=case_data) # 结果转为字典 result = res.json() msg = case.title success_msg = do_yaml.read_yaml('msg', 'success_result') fail_msg = do_yaml.read_yaml('msg', 'fail_result') # 获取行号 row = case.case_id + 1 try: # assertEqual第三个参数为用例执行失败之后的提示信息 self.assertEqual(expected, result['code'], msg=msg) # 充值成功之后再去数据库取当前金额对比 if check_sql: new_amount = round( float(self.do_mysql.run_sql(check_sql)['leave_amount']), 2) recharge_amount = json.loads(case_data)['amount'] actual_amount = round(new_amount - old_amount, 2) self.assertEqual(recharge_amount, actual_amount, msg=msg) except AssertionError as e: # 输出日志 do_logs.info("{}用例执行有误".format(msg)) # 写入用例执行结果 self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'result_col'), value=fail_msg) do_logs.error('具体异常为{}'.format(e)) raise e else: do_logs.info('{}用例执行通过'.format(msg)) # 写入用例执行结果 self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'result_col'), value=success_msg) # 执行用例通过后,判断返回报文中有没有token,有的话取出加到请求头中 if 'token_info' in res.text: self.do_requests.add_headers({"Authorization": "Bearer " + \ result['data']['token_info']['token']}) finally: # 将实际结果写入 self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'actual_col'), value=res.text)
def test_recharge(self, case): # 将期望结果取出 expected = case.expected # 参数化,将取出来的字符串进行参数替换(如果需要的话) data_str = HandleParam.to_param(case.data) # 拼接url url = do_yaml.read_yaml('api', 'url') + case.url # 判断用例种sql语句是否存在,存在的时候去做金额的查询(在充值之前) check_sql = case.check_sql # 如果SQL不为空,则进行参数替换,并且获取当前金额 if check_sql: check_sql = HandleParam.to_param(check_sql) mysql_data = self.do_mysql.run(check_sql) old_amount = round(float(mysql_data['leave_amount']), 2) # 不是float和int,是decimal类型 # 向接口发起请求 res = self.do_request.send(url=url, method=case.request_method, data=data_str) # 获取的报文转换为字典 result = res.json() msg = case.title success_msg = do_yaml.read_yaml('msg', 'success_result') fail_msg = do_yaml.read_yaml('msg', 'fail_result') row = case.case_id + 1 # assertEqual第三个参数为用例执行失败之后的提示信息 try: self.assertEqual(expected, result['code'], msg=msg) # 充值成功之后进行金额数值的校验 if check_sql: # 去数据库取充值后的金额 new_amount = round( float(self.do_mysql.run(check_sql)['leave_amount']), 2) # new_amount = result['data']['leave_amount'] recharge_amount = json.loads(data_str)['amount'] actual_amount = round(new_amount - old_amount, 2) self.assertEqual(recharge_amount, actual_amount, msg=msg) except AssertionError as e: # 将用例执行结果写入到result_col列 do_log.info('{}用例执行有误'.format(case.title)) self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'result_col'), value=fail_msg) do_log.error('具体异常为{}'.format(e)) raise e else: do_log.info('{}用例执行通过'.format(case.title)) self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'result_col'), value=success_msg) # 判断返回报文中是否有token,如果有则将token取出加入到请求头中 if result.get('data'): if result.get('data').get('token_info'): self.do_request.add_headers({"Authorization": \ "Bearer " + result['data']['token_info']['token']}) finally: # 将响应实际结果写入到actual_col列 self.excel.write_data(row=row, column=do_yaml.read_yaml( 'excel', 'actual_col'), value=res.text)
from scripts.handle_path import REPORTS_DIR, USER_ACCOUNTS_FILE_DIR, CASES_DIR # 导入初始化三个用户的模块 from scripts.handle_user import UserInit # 运行测试前先判断用户是否已经有初始化,存在目录则不需要执行初始化 if not os.path.exists(USER_ACCOUNTS_FILE_DIR): UserInit.user_init() # 创建测试套件 # suite = unittest.TestSuite() # # # 加载用例到测试套件 # loader = unittest.TestLoader() # suite.addTest(loader.loadTestsFromModule(test_register_case)) # suite.addTest(loader.loadTestsFromModule(test_login_case)) suite = unittest.defaultTestLoader.discover(CASES_DIR) # 添加报告路径 result_full_path = do_yaml.read_yaml('report', 'report_name') + '_' + \ datetime.strftime(datetime.now(), '%Y%m%d%H%M%S') + '.html' result_full_path = os.path.join(REPORTS_DIR, result_full_path) with open(result_full_path, 'wb') as f: runner = HTMLTestRunner(stream=f, title=do_yaml.read_yaml('report', 'title'), description=do_yaml.read_yaml( 'report', 'description'), tester=do_yaml.read_yaml('report', 'tester')) runner.run(suite)