def create_new_user(regname, pwd="Gl123456"): """ 创建一个用户 :param pwd: :param regname: :return: """ handle_mysql = HandleMysql() send_request = HandleRequest() url = do_config("api", "url") + "/member/register" sql = "SELECT Id FROM member WHERE MobilePhone=%s;" while True: mobilephone = handle_mysql.create_not_existed_tel() data = {"mobilephone": mobilephone, "pwd": pwd, "regname": regname} send_request(method="post", url=url, data=data) result = handle_mysql(sql=sql, args=(mobilephone,)) if result: user_id = result["Id"] break user_dict = { regname: { "Id": user_id, "regname": regname, "mobilephone": mobilephone, "pwd": pwd } } handle_mysql.close() send_request.close() return user_dict
def setUpClass(cls): # 构造请求参数 cls.do_request = HandleRequest() # 创建HandleRequest对象 cls.do_request.add_headers(do_yaml.get_data( "api", "api_version")) # 添加请求头到公共请求头 do_log.info("开始执行用例")
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): cls.do_request = HandleRequest() cls.do_request.add_headers(do_yaml.get_data("api", "api_version")) cls.do_mysql = HandleMysql() # cls.do_mysql.create_not_existed_mobile() do_log.info("开始执行用例")
def setUpClass(cls) -> None: # 创建请求对象 cls.do_request = HandleRequest() # 添加公共请求头 cls.do_request.add_headers(do_yaml.read("api", "version")) #创建mysql对象 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()
class TestCaseLogin(unittest.TestCase): do_request = HandleRequest() do_config = HandleConfig(CONFIG_REQUEST) do_excel = HandleExcel(DATA_CASES, 'login') cases = do_excel.get_cases() do_log = HandleLog do_re = Handle_Re pass_result = do_config.get_value('result', 'pass_result') fail_result = do_config.get_value('result', 'fail_result') @classmethod def setUpClass(cls): cls.one_file = open(REPORTS_ALL_PATH, mode='a+', encoding='utf-8') cls.one_file.write('{:=^40s}\n'.format('开始执行登录接口用例')) @classmethod def tearDownClass(cls): cls.one_file.write('{:=^40s}\n\n'.format('登录接口用例执行结束')) cls.one_file.close() @data(*cases) def test_login(self, one_case): # 拼接完整的url new_url = self.do_config.get_value('url', 'head_url') + one_case['url'] # 获取请求方式 method = one_case['method'] # 获取input_data数据 # input_data = one_case['input_data'] # 对excel的input_data数据进行参数化 new_data = self.do_re.login_parameterization(one_case['input_data']) # 发送请求接收请求后的结果 result_real = self.do_request.send_request(url=new_url, data=eval(new_data), method=method).text try: self.assertIn(one_case['expected'], result_real, msg='登录接口请求成功') self.one_file.write('{},执行的结果为:{}\n'.format( one_case['title'], self.pass_result)) self.do_excel.write_cell(row=one_case['case_id'] + 1, column=7, actual=result_real, result=self.pass_result) except AssertionError as err: self.one_file.write('{}执行的结果为:{},具体的异常为:{}\n'.format( one_case['title'], self.fail_result, err)) self.do_excel.write_cell(row=one_case['case_id'] + 1, column=7, actual=result_real, result=self.fail_result) raise err self.do_request.close_request()
def setUpClass(cls): # setUpClass是unittest框架的方法,会被unittest框架自动调用 """ 在当前类中所有实例方法执行之前会被调用一次 重写父类的类方法 :return: """ cls.send_request = HandleRequest() do_log.info("\n\n{:=^40s}".format("开始执行加标功能用例"))
class TestRegister(unittest.TestCase): handleExcel = HandleExcel(DATA_CASES, 'register') cases = handleExcel.get_cases() do_config = HandleConfig(CONFIG_REQUEST) head_url = do_config.get_value('url', 'head_url') do_request = HandleRequest() # 用例执行通过信息 pass_result = do_config.get_value('result', 'pass_result') # 用例执行不通过信息 fail_result = do_config.get_value('result', 'fail_result') do_re = Handle_Re() @classmethod def setUpClass(cls): cls.one_file = open(REPORTS_ALL_PATH, mode='a+', encoding='utf-8') cls.one_file.write('{:=^40s}\n'.format('开始执行注册接口用例')) @classmethod def tearDownClass(cls): cls.one_file.write('{:=^40s}\n\n'.format('注册接口用例执行结束')) cls.one_file.close() @data(*cases) def test_register(self, one_case): # 注册接口的url new_url = self.head_url + one_case['url'] # 对用例中的数据进行参数化 new_data = self.do_re.register_parameterization(one_case['input_data']) method = one_case['method'] # 发送注册接口的请求 result_real = self.do_request.send_request(url=new_url, data=eval(new_data), method=method).text try: self.assertIn(one_case['expected'], result_real, msg='注册接口请求成功') self.one_file.write('{},执行的结果为:{}\n'.format( one_case['title'], self.pass_result)) self.handleExcel.write_cell(row=one_case['case_id'] + 1, column=7, actual=result_real, result=self.pass_result) except AssertionError as err: self.one_file.write('{}执行的结果为:{},具体的异常为:{}\n'.format( one_case['title'], self.fail_result, err)) self.handleExcel.write_cell(row=one_case['case_id'] + 1, column=7, actual=result_real, result=self.fail_result) raise err self.do_request.close_request()
def get_phone(cls, username, password='******', type=1): hr = HandleRequest() hm = HandleMysql() base_url = hy.read_yaml('api', 'load') register_url = hy.read_yaml('api', 'register') all_url = ''.join((base_url, register_url)) while True: phone = hm.get_non_existent() data = { "mobile_phone": phone, "pwd": password, "type": type, "reg_name": username } hr.common_head(hy.read_yaml('api', 'header')) result = hr.send(url=all_url, data=data) if result.json()['code'] == 0 and result.json()['msg'] == 'OK': break user_id = hm.get_mysql_result(sql=hy.read_yaml('mysql', 'user_id'), args=phone) result_data = { username: { "mobilephone": phone, "pwd": password, "user_id": user_id[0]['id'], "reg_name": username } } hr.close() hm.close() return result_data
def get_phone(cls, user, password="******", type_num=1): hr = HandleRequest() hm = HandleMysql() hr.common_head({'X-Lemonban-Media-Type': 'lemonban.v2'}) base_url = hy.read_yaml('api', 'load') register_url = hy.read_yaml('api', 'register') all_url = ''.join((base_url, register_url)) while True: # 获取在数据库中不存在的电话号码 phone = hm.get_right_phone() data = { "mobile_phone": phone, "pwd": password, "type": type_num, "reg_name": user } result = hr.send(url=all_url, data=data) if result.json()['code'] == 0 and result.json()["msg"] == "OK": break my_result = hm.get_mysql_result(hy.read_yaml('mysql', 'user_id'), args=phone) user_id = my_result[0]['id'] result_data = { user: { "user_phone": phone, "pwd": password, "user_id": user_id, "reg_name": user } } hm.close() hr.close() return result_data
def generate_phone(cls, reg_name, pwd='12345678', reg_type=1): hr = HandleRequest() hm = HandleMysql() phone = hm.get_no_exist_phone() header = hy.read_yaml('request', 'header') hr.common_head(header) data = { "mobile_phone": phone, "pwd": pwd, 'type': reg_type, 'reg_name': reg_name } value_result = hr.send(url=hy.read_yaml('register', 'url'), data=data) if value_result.json()['code'] == 0: result_phone = value_result.json()['data']['mobile_phone'] user_id = value_result.json()['data']['id'] person_result = { reg_name: { "mobile_phone": result_phone, 'pwd': pwd, "type": reg_type, "id": user_id, "reg_name": reg_name } } hr.close() hm.close() return person_result
def setUpClass(cls): # 构造请求参数 cls.do_request = HandleRequest() # 创建HandleRequest对象 cls.do_request.add_headers(do_yaml.get_data( "api", "api_version")) # 添加请求头到公共请求头 cls.do_mysql = HandleMysql() # 创建HandleMysql对象 # cls.do_mysql.create_not_existed_mobile() do_log.info("开始执行用例")
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 setUpClass(cls): # 创建HandleRequest对象 cls.do_request = HandleRequest() # 获取url版本请求头数据并添加至请求头中 cls.do_request.add_headers(do_yaml.get_data("api", "api_version")) # 创建HandleMysql对象 cls.do_mysql = HandleMysql() # 创建一个不存在的用户id,并加入到全局数据池中 setattr(GlobalData, "${not_existed_id}", cls.do_mysql.get_not_existed_user_id()) do_log.info("开始执行用例")
def set_up(): hr = HandleRequest() hm = HandleMysql() hr.common_head(hy.read_yaml('api', 'header')) yield hr, hm, hy, hl hr.close() hm.close()
def create_new_user(regname, pwd='123456'): ''' 新建用户的封装类 ''' do_config = HandleConfig(CONFIG_REQUEST) do_request = HandleRequest() do_mysql = HandleMysql() register_url = do_config.get_value('url', 'register_url') sql = "SELECT Id FROM member WHERE MobilePhone = %s" while True: mobile = do_mysql.create_not_existed_mobile() data = {"regname": regname, "mobilephone": mobile, "pwd": pwd} do_request.send_request(url=register_url, data=data, method='post') result = do_mysql.do_execute(sql, args=(mobile, )) if result: user_id = result['Id'] break user_dict = { regname: { "user_id": user_id, "mobile": mobile, "pwd": pwd, "regname": regname } } do_mysql.close() do_request.close_request() return user_dict
def set_up(): hr = HandleRequest() hm = HandleMysql() hl = HandleYaml(PERSONPHONE_PATH) hr.common_head(hy.read_yaml('request', 'header')) yield hr, hm, hl hr.close() hm.close()
def create_new_user(reg_name, pwd="aaa123", user_type=1): """ 创建一个用户 :param reg_name: 用户名 :param pwd: 密码 :param user_type: 用户类型 :return: 存储一个用户信息, 嵌套字典的字典(以用户名为key, 以用户信息所在字典为value) """ # 建立连接 do_mysql = HandleMysql() do_request = HandleRequest() # 添加公共请求头 do_request.add_headers(do_yaml.read('api', 'version')) url = do_yaml.read('api', 'prefix') + '/member/register' sql = do_yaml.read('mysql', 'select_userid_sql') while True: mobile_phone = do_mysql.create_not_existed_mobile() data = { "mobile_phone": mobile_phone, "pwd": pwd, "reg_name": reg_name, "type": user_type } # 先注册接口发起请求 do_request.send(url, data=data) # 查询数据库, 获取用户id result = do_mysql.run(sql=sql, args=(mobile_phone, )) if result: user_id = result["id"] break # 构造用户信息字典 user_dict = { reg_name: { "id": user_id, "reg_name": reg_name, "mobile_phone": mobile_phone, "pwd": pwd } } # 关闭连接 do_mysql.close() do_request.close() return user_dict
def user_init(cls): # 获取请求头 headers = {"X-Lemonban-Media-Type": "lemonban.v2"} # 创建请求对象 do_request = HandleRequest() # 添加请求头 do_request.add_headers(headers) # url url = 'http://api.lemonban.com/futureloan/member/register' # 创建初始三个用户,如果已经创建过则不用再创 user = [{ 'mobile_phone': '', 'pwd': '12345678', 'type': 0, 'reg_name': '管理员' }, { 'mobile_phone': '', 'pwd': '12345678', 'type': 1, 'reg_name': '借款人' }, { 'mobile_phone': '', 'pwd': '12345678', 'type': 1, 'reg_name': '投资人' }] do_yaml = HandleYaml(USER_ACCOUNTS_FILE_DIR) number = HandleMysql() new_user = {} for i in user: i["mobile_phone"] = number.create_not_existed_mobile() # 发起请求 res = do_request.send(url=url, data=i).json() # 获取用户id new_user['{}'.format(i['reg_name'])] = res['data'] new_user['{}'.format(i['reg_name'])]['pwd'] = i['pwd'] # 写入配置文件 do_yaml.write_yaml(USER_ACCOUNTS_FILE_DIR, new_user) # 关闭请求 do_request.close() # 关闭数据库连接 number.close()
def create_user(reg_name, password=12345678, type=1): """ 创建用户并将用户信息,添加至全局数据池中 :param reg_name: 用户昵称 :param password: 用户密码,默认为12345678 :param type: 用户类型,默认为1,普通用户 :return: """ do_request = HandleRequest() do_mysql = HandleMysql() # 获取未注册手机号 mobile_phone = do_mysql.create_not_existed_mobile() # 构造请求参数 param = { "mobile_phone": mobile_phone, "pwd": password, "reg_name": reg_name, "type": type } # 构造请求url路径 url = "http://api.lemonban.com/futureloan/member/register" # 获取api头信息 do_request.add_headers(do_yaml.get_data("api", "api_version")) # 进行注册 res = do_request.send("POST", url, json=param) # sql = do_yaml.get_data("mysql", "select_user_sql") # do_mysql.get_values(sql, ) # 从响应报文中获取用户id user_id = res.json()["data"]["id"] # 关闭相关连接 do_request.close() do_mysql.close() # 将用户信息添加至全局数据池中 setattr(GlobalData, "${" + reg_name + "_user_tel}", mobile_phone) setattr(GlobalData, "${" + reg_name + "_user_pwd}", password) setattr(GlobalData, "${" + reg_name + "_user_id}", user_id)
def create_new_user(regname, pwd="123456"): """ 生成一个用户 :param regname: :param pwd: :return: """ handle_mysql = HandleMysql() handle_request = HandleRequest() url = cf.get_value("api", "prefix_url") + "/member/register" sql = "select Id from member where mobilephone=%s;" while True: mobile = handle_mysql.get_not_exists_mobile() data = {"mobilephone": mobile, "pwd": pwd, "regname": regname} handle_request.send_request("post", url, data) ret = handle_mysql.select(sql, args=(mobile, )) if ret: user_id = ret["Id"] break user_dict = { regname: { "Id": user_id, "regname": regname, "mobilephone": mobile, "pwd": pwd } } handle_mysql.close() handle_request.close() return user_dict
def setUpClass(cls) -> None: cls.request = HandleRequest() logger.debug("\n{:=^40s}".format("开始执行测试"))
def setUpClass(cls): cls.do_request = HandleRequest() # 添加请求头 cls.do_request.add_headers(do_yaml.read_yaml('api', 'version'))
class TestInvest(unittest.TestCase): do_re = Handle_Re() do_request = HandleRequest() do_config = HandleConfig(CONFIG_REQUEST) # 初始化HandleExcel对象 do_excel = HandleExcel(sheetname='invest') # 获取所有的用例 cases = do_excel.get_cases() pass_result = do_config.get_value('result', 'pass_result') fail_result = do_config.get_value('result', 'fail_result') @classmethod def setUpClass(cls): cls.do_mysql = HandleMysql() cls.one_file = open(REPORTS_ALL_PATH, mode='a+', encoding='utf-8') cls.one_file.write('{:=^40s}\n'.format('开始执行投资接口用例')) @classmethod def tearDownClass(cls): cls.do_mysql.close() cls.one_file.write('{:=^40s}\n\n'.format('投资接口用例执行结束')) cls.one_file.close() @data(*cases) # 对所有用例进行拆包 def test_invest(self, one_case): # 获得单个的用例,获取单个用例的请求数据 # data = one_case['input_data'] # 对请求数据进行参数化,获取到参数化后的数据 new_data = self.do_re.invest_parameterization(one_case['input_data']) # 获取请求的url地址 new_url = self.do_config.get_value('url', 'head_url') + one_case['url'] # 获取接口请求方式 method = one_case['method'] # 对接口发送请求,获取请求后的返回数据 result_data = self.do_request.send_request(url=new_url, data=eval(new_data), method=method).text if "加标成功" in result_data: check_sql = one_case['check_sql'] if check_sql: # 对sql语句进行参数化 check_sql = self.do_re.invest_parameterization(check_sql) # 获取到执行后的sql语句后的内容 result_sql = self.do_mysql.do_execute(check_sql) # loan_id = result_sql['Id'] # loan_id = result_data.get('Id') # Handle_Re.loan_id = result_data['Id'] # 第一个参数:实例对象,则会为该实例对象创建实例属性 # 第一个参数为类,则会创建类属性 # 第二个参数为属性名 # 第三个参数为具体的值 setattr(Handle_Re, "loan_id", result_sql.get('Id')) # 获取接口请求成功的标识 expected = one_case['expected'] try: self.assertIn(expected, result_data, msg='投资接口请求成功') self.one_file.write('{}执行的结果为:{}\n'.format(one_case['title'], self.pass_result)) self.do_excel.write_cell(row=one_case['case_id'] + 1, column=7, actual=result_data, result=self.pass_result) except AssertionError as err: self.one_file.write('{}执行的结果为:{},具体的异常为:{}\n'.format( one_case['title'], self.fail_result, err)) self.do_excel.write_cell(row=one_case['case_id'] + 1, column=7, actual=result_data, result=self.fail_result) raise err self.do_request.close_request()
def setUpClass(cls) -> None: cls.do_request = HandleRequest() cls.do_request.add_headers(do_yaml.read("api", "version"))
def setUpClass(cls): cls.do_request = HandleRequest() # 创建HandleRequest对象 cls.do_request.add_headers(do_yaml.read('api', 'version')) # 添加公共的请求头, url版本号
def setUpClass(cls): # 3、构造请求参数 cls.do_request = HandleRequest() cls.do_request.add_headers(do_yaml.get_data("api", "api_version")) do_log.info("开始执行用例")
def setUpClass(cls): cls.one_session = HandleRequest() do_log.info("{:=^40s}".format("用例开始执行"))
def setUpClass(cls) -> None: #所有用例执行前会被调用一次 # 创建请求对象 cls.do_request = HandleRequest() # 添加公共请求头 cls.do_request.add_headers(do_yaml.read("api", "version"))