def __init__(self, name=None): # 1、创建Logger对象 # 相当于日志记录工具 if name is None: self.my_logger = logging.getLogger("testcase") else: self.my_logger = logging.getLogger(name) # 2、设置日志器的日志等级 # self.my_logger.setLevel("DEBUG") self.my_logger.setLevel(do_yaml.get_data("log", "logger_level")) # 3、创建日志输出渠道(日志显示的地方) console_handler = logging.StreamHandler() console_handler.setLevel("WARNING") # file_handler = logging.FileHandler("testcase.log", encoding="utf-8") # file_handler = logging.FileHandler(do_yaml.get_data("log", "log_filename"), encoding="utf-8") log_full_path = os.path.join(LOG_PATH, do_yaml.get_data("log", "log_filename")) file_handler = logging.FileHandler(log_full_path, encoding="utf-8") # 4、创建日志的显示样式(格式)并与渠道进行关联 formater = logging.Formatter( '%(asctime)s - [%(levelname)s] - [msg]: %(message)s - %(name)s - %(lineno)d' ) console_handler.setFormatter(formater) file_handler.setFormatter(formater) # 5、日志器对象与日志输出渠道(展示的地方)进行关联 self.my_logger.addHandler(console_handler) self.my_logger.addHandler(file_handler)
def __init__(self): self.conn = pymysql.connect( host=do_yaml.get_data('mysql', 'host'), user=do_yaml.get_data('mysql', 'user'), password=do_yaml.get_data('mysql', 'password'), db=do_yaml.get_data('mysql', 'db'), port=do_yaml.get_data('mysql', 'port'), charset='utf8', # 这里只能写为utf8 cursorclass=pymysql.cursors.DictCursor) self.cursor = self.conn.cursor()
def test_recharge(self, one_testcase): new_url = do_yaml.get_data("api", "base_url") + one_testcase.url # 1、在充值之前,查询当前用例的金额 # 2、进行充值 res = self.do_request.send(one_testcase.method, new_url, json=one_testcase.data) # real_code = res.json()["code"] try: self.assertIn(one_testcase.expected_value, res.text, one_testcase.name) # 3、查询充值成功之后的金额 except AssertionError as e: # my_logger.error(f"{one_testcase.name}:具体异常为{e}") do_log.error(f"{one_testcase.name}:具体异常为{e}") self.do_excel.write_data(one_testcase, res.text, "失败") raise e else: # if one_testcase.id == 2: # a.如果响应报文中含有token_info,说明当前用例为登录接口用例 # b.从响应报文中获取token,然后添加至请求头中 if "token_info" in res.text: token = res.json()["data"]["token_info"]["token"] self.do_request.add_headers("Authorization", f"Bearer {token}") self.do_excel.write_data(one_testcase, res.text, "成功")
def to_encrypt(cls, msg, pub_key=None): """ 非对称加密 :param msg: 待加密字符串或者字节 :param pub_key: 公钥 :return: 密文 """ if isinstance(msg, str): # 如果msg为字符串, 则转化为字节类型 msg = msg.encode('utf-8') elif isinstance(msg, bytes): # 如果msg为字节类型, 则无需处理 pass else: # 否则抛出异常 raise TypeError('msg必须为字符串或者字节类型!') if not pub_key: # 如果pub_key为空, 则使用全局公钥 # 获取公钥文件名 public_key_filename = do_yaml.get_data("api", "public_key_filename") # 获取公钥文件所在路径 public_key_path = os.path.join(CONF_PATH, public_key_filename) with open(public_key_path, 'rb') as file: # 读取公钥 pub_key = file.read() elif isinstance(pub_key, str): # 如果pub_key为字符串, 则转化为字节类型 pub_key = pub_key.encode('utf-8') elif isinstance(pub_key, bytes): # 如果msg为字节类型, 则无需处理 pass else: # 否则抛出异常 raise TypeError('pub_key必须为None、字符串或者字节类型!') public_key_obj = rsa.PublicKey.load_pkcs1_openssl_pem(pub_key) # 创建 PublicKey 对象 cryto_msg = rsa.encrypt(msg, public_key_obj) # 生成加密文本 cipher_base64 = base64.b64encode(cryto_msg) # 将加密文本转化为 base64 编码 return cipher_base64.decode() # 将字节类型的 base64 编码转化为字符串类型
def test_add(self, one_testcase): # 将excel中读取的请求参数进行参数化 new_data = Parameterize.to_parma(one_testcase.data) # 拼接请求URL地址 new_url = do_yaml.get_data("api", "base_url") + one_testcase.url # 进行加标 res = self.do_request.send(one_testcase.method, new_url, json=new_data) # 获取响应数据并转化为字典类型 actual_value = res.json() try: # 断言:预期结果==实际结果,断言结果 self.assertEqual(one_testcase.expected_value, actual_value.get("code"), one_testcase.name) except AssertionError as e: # 此处使用日志器来记录日志! do_log.error(f"{one_testcase.name}:具体异常为{e}") # 把执行结果写入excel中“actual"和”result“ self.do_excel.write_data(one_testcase, res.text, "失败") # 再次抛出异常 raise e else: # if one_testcase.id == 2: # a.如果响应报文中含有token_info,说明当前用例为登录接口用例 # b.从响应报文中获取token,然后添加至请求头中 if "token_info" in res.text: token = res.json()["data"]["token_info"]["token"] # add_headers需要传字典类型 # self.do_request.add_headers("Authorization", f"Bearer {token}") headers = {"Authorization": "Bearer " + token} self.do_request.add_headers(headers) self.do_excel.write_data(one_testcase, res.text, "成功")
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 test_register(self, one_testcase): new_url = do_yaml.get_data("api", "base_url") + one_testcase.url res = self.do_request.send(one_testcase.method, new_url, json=one_testcase.data) real_code = res.json()["code"] # row = testcase_dict["id"] + 1 # self.do_excel.write_data(row, 7, res.text) # name = testcase_dict["name"] try: self.assertEqual(one_testcase.expected_value, real_code, one_testcase.name) except AssertionError as e: # print("此处需要使用日志器来记录日志!") # my_logger.error(f"{one_testcase.name}:具体异常为{e}") do_log.error(f"{one_testcase.name}:具体异常为{e}") # print(f"具体异常为:{e}") # self.do_excel.write_data(row, 8, "失败") self.do_excel.write_data(one_testcase, res.text, "失败") raise e else: # self.do_excel.write_data(row, 8, "成功") # do_log.debug(res.text) self.do_excel.write_data(one_testcase, res.text, "成功")
def test_login(self, one_testcase): # 将excel中读取的请求参数进行参数化 new_data = Parameterize.to_parma(one_testcase.data) new_url = do_yaml.get_data("api", "base_url") + one_testcase.url res = self.do_request.send(one_testcase.method, new_url, json=new_data) # 获取响应数据并转化为字典类型 actual_value = res.json() # 将expected_value期望值转化为字典类型 expect_result = json.loads(one_testcase.expected_value, encoding='utf-8') try: # self.assertIn(one_testcase.expected_value, # res.text, # one_testcase.name) self.assertEqual(expect_result.get('code'), actual_value.get('code'), one_testcase.name) self.assertEqual(expect_result.get('msg'), actual_value.get('msg'), one_testcase.name) except AssertionError as e: do_log.error(f"{one_testcase.name}:具体异常为{e}") self.do_excel.write_data(one_testcase, res.text, "失败") raise e else: self.do_excel.write_data(one_testcase, res.text, "成功")
def test_register(self, one_testcase): # 在每条用例执行之前,获取未注册的手机号码,然后更新全局数据池 setattr(GlobalData, "${not_existed_tel}", self.do_mysql.create_not_existed_mobile()) # 将excel中读取的请求参数进行参数化 new_data = Parameterize.to_parma(one_testcase.data) # 拼接请求URL地址 new_url = do_yaml.get_data("api", "base_url") + one_testcase.url # 发送接口请求方法 res = self.do_request.send(one_testcase.method, new_url, json=new_data) # 获取接口返回数据中的code值 real_code = res.json()["code"] # row = testcase_dict["id"] + 1 # self.do_excel.write_data(row, 7, res.text) # name = testcase_dict["name"] try: # 断言:预期结果==实际结果,断言结果 self.assertEqual(one_testcase.expected_value, real_code, one_testcase.name) except AssertionError as e: # print("此处需要使用日志器来记录日志!") # my_logger.error(f"{one_testcase.name}:具体异常为{e}") # 此处使用日志器来记录日志! do_log.error(f"{one_testcase.name}:具体异常为{e}") # print(f"具体异常为:{e}") # self.do_excel.write_data(row, 8, "失败") # 把执行结果写入excel中“actual"和”result“ self.do_excel.write_data(one_testcase, res.text, "失败") raise e else: # self.do_excel.write_data(row, 8, "成功") # do_log.debug(res.text) # 把执行结果写入excel中“actual"和”result“ self.do_excel.write_data(one_testcase, res.text, "成功")
def setUpClass(cls): # 构造请求参数 cls.do_request = HandleRequest() # 创建HandleRequest对象 cls.do_request.add_headers(do_yaml.get_data( "api", "api_version")) # 添加请求头到公共请求头 do_log.info("开始执行用例")
class TestRegister(unittest.TestCase): # 创建handleexcel对象 do_excel = HandleExcel(do_yaml.get_data("excel", "filename"), "register") testcases_data = do_excel.read_data() # 嵌套用例excel对象的列表 @classmethod 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("开始执行用例") @classmethod def tearDownClass(cls): # 释放资源 cls.do_request.close() cls.do_mysql.close() do_log.info("用例执行结束") @ddt.data(*testcases_data) def test_register(self, one_testcase): # 在每条用例执行之前,获取未注册的手机号码,然后更新全局数据池 setattr(GlobalData, "${not_existed_tel}", self.do_mysql.create_not_existed_mobile()) # 将excel中读取的请求参数进行参数化 new_data = Parameterize.to_parma(one_testcase.data) # 拼接请求URL地址 new_url = do_yaml.get_data("api", "base_url") + one_testcase.url # 发送接口请求方法 res = self.do_request.send(one_testcase.method, new_url, json=new_data) # 获取接口返回数据中的code值 real_code = res.json()["code"] # row = testcase_dict["id"] + 1 # self.do_excel.write_data(row, 7, res.text) # name = testcase_dict["name"] try: # 断言:预期结果==实际结果,断言结果 self.assertEqual(one_testcase.expected_value, real_code, one_testcase.name) except AssertionError as e: # print("此处需要使用日志器来记录日志!") # my_logger.error(f"{one_testcase.name}:具体异常为{e}") # 此处使用日志器来记录日志! do_log.error(f"{one_testcase.name}:具体异常为{e}") # print(f"具体异常为:{e}") # self.do_excel.write_data(row, 8, "失败") # 把执行结果写入excel中“actual"和”result“ self.do_excel.write_data(one_testcase, res.text, "失败") raise e else: # self.do_excel.write_data(row, 8, "成功") # do_log.debug(res.text) # 把执行结果写入excel中“actual"和”result“ self.do_excel.write_data(one_testcase, res.text, "成功")
def test_recharge(self, one_testcase): # 将excel中读取的请求参数进行参数化 new_data = Parameterize.to_parma(one_testcase.data) # 拼接请求URL地址 new_url = do_yaml.get_data("api", "base_url") + one_testcase.url # 1、在充值之前,查询当前用例的金额 # 在发起请求之前, 查询当前账户金额 check_sql = one_testcase.check_sql if check_sql: # 参数化excel中check_sql列中的值,check_sql列存放的是一条查询语句 check_sql = Parameterize.to_parma(check_sql) # 使用check_sql列中的查询语句,查寻数据库中的值,返回的是一个字典 mysql_data = self.do_mysql.get_one_value(sql=check_sql) amount_before = float(mysql_data['leave_amount'] ) # 不是float浮点数, 也不是int类型, 是decimal数据类型 # 2、进行充值 res = self.do_request.send(one_testcase.method, new_url, json=new_data) # 获取响应数据并转化为字典类型 actual_value = res.json() try: # one_testcase.expected_value为int类型,需要转化为字符串类型 # self.assertIn(one_testcase.expected_value, # res.text, # one_testcase.name) self.assertEqual(one_testcase.expected_value, actual_value.get("code"), one_testcase.name) # 3、查询充值成功之后的金额 # 如果check_sql不为空, 说明要进行数据校验 if check_sql: mysql_data = self.do_mysql.get_one_value(sql=check_sql) amount_after = float(mysql_data['leave_amount']) one_dict = json.loads(new_data, encoding='utf-8') currrent_recharge_amount = one_dict['amount'] actual_amount = amount_before + currrent_recharge_amount self.assertEqual(actual_amount, amount_after, msg="数据库中充值的金额有误") except AssertionError as e: do_log.error(f"{one_testcase.name}:具体异常为{e}") self.do_excel.write_data(one_testcase, res.text, "失败") raise e else: # if one_testcase.id == 2: # a.如果响应报文中含有token_info,说明当前用例为登录接口用例 # b.从响应报文中获取token,然后添加至请求头中 if "token_info" in res.text: token = actual_value["data"]["token_info"]["token"] # add_headers需要传字典类型 # self.do_request.add_headers("Authorization", f"Bearer {token}") headers = {"Authorization": "Bearer " + token} self.do_request.add_headers(headers) self.do_excel.write_data(one_testcase, res.text, "成功")
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 is_existed_mobile(self, mobile): """ 判断指定的手机号在数据库中是否存在 :param mobile: 11位手机号组成的字符串 :return: True or False """ # sql = "SELECT mobile_phone FROM member WHERE mobile_phone=%s;" sql = do_yaml.get_data('mysql', 'select_user_sql') if self.get_one_value(sql, args=[mobile]): # 手机号已经存在,则返回True,否则返回False return True else: return False
class TestLogin(unittest.TestCase): # 创建handleexcel对象 do_excel = HandleExcel(do_yaml.get_data("excel", "filename"), "login") testcases_data = do_excel.read_data() # 嵌套用例excel对象的列表 @classmethod def setUpClass(cls): # 构造请求参数 cls.do_request = HandleRequest() # 创建HandleRequest对象 cls.do_request.add_headers(do_yaml.get_data( "api", "api_version")) # 添加请求头到公共请求头 do_log.info("开始执行用例") @classmethod def tearDownClass(cls): # 释放资源 cls.do_request.close() do_log.info("用例执行结束") @ddt.data(*testcases_data) def test_login(self, one_testcase): # 将excel中读取的请求参数进行参数化 new_data = Parameterize.to_parma(one_testcase.data) # 拼接请求URL地址 new_url = do_yaml.get_data("api", "base_url") + one_testcase.url # 发送接口请求方法 res = self.do_request.send(one_testcase.method, new_url, json=new_data) # 获取响应数据并转化为字典类型 actual_value = res.json() # 将expected_value期望值转化为字典类型 expect_result = json.loads(one_testcase.expected_value, encoding='utf-8') try: # self.assertIn(one_testcase.expected_value, # res.text, # one_testcase.name) # 断言: 预期结果==实际结果,断言结果 self.assertEqual(expect_result.get('code'), actual_value.get('code'), one_testcase.name) self.assertEqual(expect_result.get('msg'), actual_value.get('msg'), one_testcase.name) except AssertionError as e: # 此处使用日志器来记录日志! do_log.error(f"{one_testcase.name}:具体异常为{e}") # 把执行结果写入excel中“actual"和”result“ self.do_excel.write_data(one_testcase, res.text, "失败") raise e else: # 把执行结果写入excel中“actual"和”result“ self.do_excel.write_data(one_testcase, res.text, "成功")
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 test_invest(self, one_testcase): # 将excel中读取的请求参数进行参数化 new_data = Parameterize.to_parma(one_testcase.data) # 拼接请求URL地址 new_url = do_yaml.get_data("api", "base_url") + one_testcase.url # 进行投资 res = self.do_request.send(one_testcase.method, new_url, json=new_data) # 获取响应数据并转化为字典类型 actual_value = res.json() try: # 断言:预期结果==实际结果,断言结果 self.assertEqual(one_testcase.expected_value, actual_value.get("code"), one_testcase.name) except AssertionError as e: # 此处使用日志器来记录日志! do_log.error(f"{one_testcase.name}:具体异常为{e}") # 把执行结果写入excel中“actual"和”result“ self.do_excel.write_data(one_testcase, res.text, "失败") raise e else: # if one_testcase.id == 2: # a.如果响应报文中含有token_info,说明当前用例为登录接口用例 # b.从响应报文中获取token,然后添加至请求头中 if "token_info" in res.text: token = res.json()["data"]["token_info"]["token"] # add_headers需要传字典类型 headers = {"Authorization": "Bearer " + token} self.do_request.add_headers(headers) check_sql_str = one_testcase.check_sql if check_sql_str: # 将check_sql json格式的字符串转化为字典 check_sql_dict = json.loads(check_sql_str, encoding='utf-8') if 'loan_id' in check_sql_dict: # 获取查询loan id的sql语句 loan_id_sql = check_sql_dict.get('loan_id') # 将sql语句进行参数化 loan_id_sql = Parameterize.to_parma(loan_id_sql) mysql_data = self.do_mysql.get_one_value(sql=loan_id_sql) load_id = mysql_data['id'] # 获取loan_id # 设置loan_id为GlobalData的类属性 setattr(GlobalData, '${loan_id}', load_id) self.do_excel.write_data(one_testcase, res.text, "成功")
def test_invest(self, one_testcase): if 8 >= one_testcase.id >= 3: self.do_request.get_ids() elif 22 >= one_testcase.id >= 15: self.do_request.get_gjids() elif 38 >= one_testcase.id >= 33: self.do_request.get_ghxsid() new_data = Parameterize.to_parma(one_testcase.data) new_url = do_yaml.get_data("api", "base_url") + one_testcase.url # 进行加标 res = self.do_request.send(one_testcase.method, new_url, json=new_data) # 获取响应数据并转化为字典类型 actual_value = res.json() try: self.assertEqual(one_testcase.expected_value, actual_value.get("errcode"), one_testcase.name) except AssertionError as e: do_log.error(f"{one_testcase.name}:具体异常为{e}") self.do_excel.write_data(one_testcase, res.text, "失败") raise e else: # if one_testcase.id == 2: # a.如果响应报文中含有token_info,说明当前用例为登录接口用例 # b.从响应报文中获取token,然后添加至请求头中 if "token" in res.text and one_testcase.id == 1: token = res.json()["data"]["token"] # add_headers需要传字典类型 headers = {"Authorization": "Bearer " + token} self.do_request.add_headers(headers) # check_sql_str = one_testcase.check_sql # if check_sql_str: # # 将check_sql json格式的字符串转化为字典 # check_sql_dict = json.loads(check_sql_str, encoding='utf-8') # if 'loan_id' in check_sql_dict: # # 获取查询loan id的sql语句 # loan_id_sql = check_sql_dict.get('loan_id') # # 将sql语句进行参数化 # loan_id_sql = Parameterize.to_parma(loan_id_sql) # mysql_data = self.do_mysql.get_one_value(sql=loan_id_sql) # # load_id = mysql_data['id'] # 获取loan_id # # 设置loan_id为GlobalData的类属性 # setattr(GlobalData, '${loan_id}', load_id) self.do_excel.write_data(one_testcase, res.text, "成功")
class TestRecharge(unittest.TestCase): do_excel = HandleExcel(do_yaml.get_data("excel", "filename"), "recharge") testcases_data = do_excel.read_data() # 嵌套字典的列表 @classmethod def setUpClass(cls): # 3、构造请求参数 cls.do_request = HandleRequest() cls.do_request.add_headers(do_yaml.get_data("api", "api_version")) do_log.info("开始执行用例") @classmethod def tearDownClass(cls): cls.do_request.close() do_log.info("用例执行结束") @ddt.data(*testcases_data) def test_recharge(self, one_testcase): new_url = do_yaml.get_data("api", "base_url") + one_testcase.url # 1、在充值之前,查询当前用例的金额 # 2、进行充值 res = self.do_request.send(one_testcase.method, new_url, json=one_testcase.data) # real_code = res.json()["code"] try: self.assertIn(one_testcase.expected_value, res.text, one_testcase.name) # 3、查询充值成功之后的金额 except AssertionError as e: # my_logger.error(f"{one_testcase.name}:具体异常为{e}") do_log.error(f"{one_testcase.name}:具体异常为{e}") self.do_excel.write_data(one_testcase, res.text, "失败") raise e else: # if one_testcase.id == 2: # a.如果响应报文中含有token_info,说明当前用例为登录接口用例 # b.从响应报文中获取token,然后添加至请求头中 if "token_info" in res.text: token = res.json()["data"]["token_info"]["token"] self.do_request.add_headers("Authorization", f"Bearer {token}") self.do_excel.write_data(one_testcase, res.text, "成功")
class TestLogin(unittest.TestCase): do_excel = HandleExcel(do_yaml.get_data("excel", "filename"), "login") testcases_data = do_excel.read_data() # 嵌套字典的列表 @classmethod def setUpClass(cls): # 3、构造请求参数 cls.do_request = HandleRequest() cls.do_request.add_headers(do_yaml.get_data("api", "api_version")) do_log.info("开始执行用例") @classmethod def tearDownClass(cls): cls.do_request.close() do_log.info("用例执行结束") @ddt.data(*testcases_data) def test_login(self, one_testcase): # 将excel中读取的请求参数进行参数化 new_data = Parameterize.to_parma(one_testcase.data) new_url = do_yaml.get_data("api", "base_url") + one_testcase.url res = self.do_request.send(one_testcase.method, new_url, json=new_data) # 获取响应数据并转化为字典类型 actual_value = res.json() # 将expected_value期望值转化为字典类型 expect_result = json.loads(one_testcase.expected_value, encoding='utf-8') try: # self.assertIn(one_testcase.expected_value, # res.text, # one_testcase.name) self.assertEqual(expect_result.get('code'), actual_value.get('code'), one_testcase.name) self.assertEqual(expect_result.get('msg'), actual_value.get('msg'), one_testcase.name) except AssertionError as e: do_log.error(f"{one_testcase.name}:具体异常为{e}") self.do_excel.write_data(one_testcase, res.text, "失败") raise e else: self.do_excel.write_data(one_testcase, res.text, "成功")
class TestRegister(unittest.TestCase): do_excel = HandleExcel(do_yaml.get_data("excel", "filename"), "register") testcases_data = do_excel.read_data() # 嵌套字典的列表 @classmethod def setUpClass(cls): # 3、构造请求参数 cls.do_request = HandleRequest() cls.do_request.add_headers(do_yaml.get_data("api", "api_version")) do_log.info("开始执行用例") @classmethod def tearDownClass(cls): cls.do_request.close() do_log.info("用例执行结束") @ddt.data(*testcases_data) def test_register(self, one_testcase): new_url = do_yaml.get_data("api", "base_url") + one_testcase.url res = self.do_request.send(one_testcase.method, new_url, json=one_testcase.data) real_code = res.json()["code"] # row = testcase_dict["id"] + 1 # self.do_excel.write_data(row, 7, res.text) # name = testcase_dict["name"] try: self.assertEqual(one_testcase.expected_value, real_code, one_testcase.name) except AssertionError as e: # print("此处需要使用日志器来记录日志!") # my_logger.error(f"{one_testcase.name}:具体异常为{e}") do_log.error(f"{one_testcase.name}:具体异常为{e}") # print(f"具体异常为:{e}") # self.do_excel.write_data(row, 8, "失败") self.do_excel.write_data(one_testcase, res.text, "失败") raise e else: # self.do_excel.write_data(row, 8, "成功") # do_log.debug(res.text) self.do_excel.write_data(one_testcase, res.text, "成功")
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)
class TestAdd(unittest.TestCase): # 创建handleexcel对象 do_excel = HandleExcel(do_yaml.get_data("excel", "filename"), "add") testcases_data = do_excel.read_data() # 嵌套用例excel对象的列表 @classmethod 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("开始执行用例") @classmethod def tearDownClass(cls): cls.do_request.close() # 关闭连接 cls.do_mysql.close() do_log.info("用例执行结束") @ddt.data(*testcases_data) def test_add(self, one_testcase): # 将excel中读取的请求参数进行参数化 new_data = Parameterize.to_parma(one_testcase.data) # 拼接请求URL地址 new_url = do_yaml.get_data("api", "base_url") + one_testcase.url # 进行加标 res = self.do_request.send(one_testcase.method, new_url, json=new_data) # 获取响应数据并转化为字典类型 actual_value = res.json() try: # 断言:预期结果==实际结果,断言结果 self.assertEqual(one_testcase.expected_value, actual_value.get("code"), one_testcase.name) except AssertionError as e: # 此处使用日志器来记录日志! do_log.error(f"{one_testcase.name}:具体异常为{e}") # 把执行结果写入excel中“actual"和”result“ self.do_excel.write_data(one_testcase, res.text, "失败") # 再次抛出异常 raise e else: # if one_testcase.id == 2: # a.如果响应报文中含有token_info,说明当前用例为登录接口用例 # b.从响应报文中获取token,然后添加至请求头中 if "token_info" in res.text: token = res.json()["data"]["token_info"]["token"] # add_headers需要传字典类型 # self.do_request.add_headers("Authorization", f"Bearer {token}") headers = {"Authorization": "Bearer " + token} self.do_request.add_headers(headers) self.do_excel.write_data(one_testcase, res.text, "成功")
class TestInvest(unittest.TestCase): """ 投资接口测试类 """ # 创建handleexcel对象 do_excel = HandleExcel(do_yaml.get_data("excel", "filename"), "invest") testcases_data = do_excel.read_data() # 嵌套用例excel对象的列表 @classmethod 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()) # 创建一个不存在的loan id,并加入到全局数据池中 setattr(GlobalData, "${not_existed_loan_id}", cls.do_mysql.get_not_existed_loan_id()) do_log.info("开始执行用例") @classmethod def tearDownClass(cls): cls.do_request.close() # 关闭连接 cls.do_mysql.close() do_log.info("用例执行结束") @ddt.data(*testcases_data) def test_invest(self, one_testcase): # 将excel中读取的请求参数进行参数化 new_data = Parameterize.to_parma(one_testcase.data) # 拼接请求URL地址 new_url = do_yaml.get_data("api", "base_url") + one_testcase.url # 进行投资 res = self.do_request.send(one_testcase.method, new_url, json=new_data) # 获取响应数据并转化为字典类型 actual_value = res.json() try: # 断言:预期结果==实际结果,断言结果 self.assertEqual(one_testcase.expected_value, actual_value.get("code"), one_testcase.name) except AssertionError as e: # 此处使用日志器来记录日志! do_log.error(f"{one_testcase.name}:具体异常为{e}") # 把执行结果写入excel中“actual"和”result“ self.do_excel.write_data(one_testcase, res.text, "失败") raise e else: # if one_testcase.id == 2: # a.如果响应报文中含有token_info,说明当前用例为登录接口用例 # b.从响应报文中获取token,然后添加至请求头中 if "token_info" in res.text: token = res.json()["data"]["token_info"]["token"] # add_headers需要传字典类型 headers = {"Authorization": "Bearer " + token} self.do_request.add_headers(headers) check_sql_str = one_testcase.check_sql if check_sql_str: # 将check_sql json格式的字符串转化为字典 check_sql_dict = json.loads(check_sql_str, encoding='utf-8') if 'loan_id' in check_sql_dict: # 获取查询loan id的sql语句 loan_id_sql = check_sql_dict.get('loan_id') # 将sql语句进行参数化 loan_id_sql = Parameterize.to_parma(loan_id_sql) mysql_data = self.do_mysql.get_one_value(sql=loan_id_sql) load_id = mysql_data['id'] # 获取loan_id # 设置loan_id为GlobalData的类属性 setattr(GlobalData, '${loan_id}', load_id) self.do_excel.write_data(one_testcase, res.text, "成功")
class TestRecharge(unittest.TestCase): # 创建handleexcel对象 do_excel = HandleExcel(do_yaml.get_data("excel", "filename"), "recharge") testcases_data = do_excel.read_data() # 嵌套用例excel对象的列表 @classmethod 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("开始执行用例") @classmethod def tearDownClass(cls): # 释放资源 cls.do_request.close() # 关闭连接 cls.do_mysql.close() do_log.info("用例执行结束") @ddt.data(*testcases_data) def test_recharge(self, one_testcase): # 将excel中读取的请求参数进行参数化 new_data = Parameterize.to_parma(one_testcase.data) # 拼接请求URL地址 new_url = do_yaml.get_data("api", "base_url") + one_testcase.url # 1、在充值之前,查询当前用例的金额 # 在发起请求之前, 查询当前账户金额 check_sql = one_testcase.check_sql if check_sql: # 参数化excel中check_sql列中的值,check_sql列存放的是一条查询语句 check_sql = Parameterize.to_parma(check_sql) # 使用check_sql列中的查询语句,查寻数据库中的值,返回的是一个字典 mysql_data = self.do_mysql.get_one_value(sql=check_sql) amount_before = float(mysql_data['leave_amount'] ) # 不是float浮点数, 也不是int类型, 是decimal数据类型 # 2、进行充值 res = self.do_request.send(one_testcase.method, new_url, json=new_data) # 获取响应数据并转化为字典类型 actual_value = res.json() try: # one_testcase.expected_value为int类型,需要转化为字符串类型 # self.assertIn(one_testcase.expected_value, # res.text, # one_testcase.name) self.assertEqual(one_testcase.expected_value, actual_value.get("code"), one_testcase.name) # 3、查询充值成功之后的金额 # 如果check_sql不为空, 说明要进行数据校验 if check_sql: mysql_data = self.do_mysql.get_one_value(sql=check_sql) amount_after = float(mysql_data['leave_amount']) one_dict = json.loads(new_data, encoding='utf-8') currrent_recharge_amount = one_dict['amount'] actual_amount = amount_before + currrent_recharge_amount self.assertEqual(actual_amount, amount_after, msg="数据库中充值的金额有误") except AssertionError as e: do_log.error(f"{one_testcase.name}:具体异常为{e}") self.do_excel.write_data(one_testcase, res.text, "失败") raise e else: # if one_testcase.id == 2: # a.如果响应报文中含有token_info,说明当前用例为登录接口用例 # b.从响应报文中获取token,然后添加至请求头中 if "token_info" in res.text: token = actual_value["data"]["token_info"]["token"] # add_headers需要传字典类型 # self.do_request.add_headers("Authorization", f"Bearer {token}") headers = {"Authorization": "Bearer " + token} self.do_request.add_headers(headers) self.do_excel.write_data(one_testcase, res.text, "成功")
# from HTMLTestRunnerNew import HTMLTestRunner from libs.HTMLTestRunnerNew import HTMLTestRunner # from handle_yaml import do_yaml from scripts.handle_yaml import do_yaml from scripts.handle_path import CASES_PATH, REPORTS_PATH from scripts.handle_user import generate_three_user # 在执行用例之后,先创建三个用户并存放在全局数据池GlobalData中 # generate_three_user() # suite = unittest.defaultTestLoader.discover(r"C:\Users\KeYou\PycharmProjects\TestApi0509\cases") suite = unittest.defaultTestLoader.discover(CASES_PATH) # html_filename = do_yaml.get_data("report", "filename") # html_filename = r"C:\Users\KeYou\PycharmProjects\TestApi0509\reports" + "\\" + html_filename # html_filename = os.path.join(REPORTS_PATH, html_filename) html_filename = do_yaml.get_data('report', 'filename') + '_' + datetime.strftime( datetime.now(), "%Y%m%d%H%M%S") + ".html" html_filename = os.path.join(REPORTS_PATH, html_filename) with open(html_filename, "wb") as file: runner = HTMLTestRunner(file, verbosity=do_yaml.get_data("report", "verbosity"), title=do_yaml.get_data("report", "title"), description=do_yaml.get_data( "report", "description"), tester=do_yaml.get_data("report", "tester")) runner.run(suite)
def setUpClass(cls): # 3、构造请求参数 cls.do_request = HandleRequest() cls.do_request.add_headers(do_yaml.get_data("api", "api_version")) do_log.info("开始执行用例")
class TestJingXianSuo(unittest.TestCase): """ 投资接口测试类 """ do_excel = HandleExcel(do_yaml.get_data("excel", "filename"), "all") testcases_data = do_excel.read_data() # 嵌套字典的列表 @classmethod def setUpClass(cls): # 创建HandleRequest对象 cls.do_request = HandleRequest() # 获取url版本请求头数据并添加至请求头中 cls.do_request.add_headers(do_yaml.get_data("api", "headers")) # 创建HandleMysql对象 # cls.do_mysql = HandleMysql() # 创建一个不存在的用户id,并加入到全局数据池中 # setattr(GlobalData, "${not_existed_id}", cls.do_mysql.get_not_existed_user_id()) # 创建一个不存在的loan id,并加入到全局数据池中 # setattr(GlobalData, "${not_existed_loan_id}", cls.do_mysql.get_not_existed_loan_id()) do_log.info("开始执行用例") @classmethod def tearDownClass(cls): cls.do_request.close() # 关闭连接 # cls.do_mysql.close() do_log.info("用例执行结束") @ddt.data(*testcases_data) def test_invest(self, one_testcase): if 8 >= one_testcase.id >= 3: self.do_request.get_ids() elif 22 >= one_testcase.id >= 15: self.do_request.get_gjids() elif 38 >= one_testcase.id >= 33: self.do_request.get_ghxsid() new_data = Parameterize.to_parma(one_testcase.data) new_url = do_yaml.get_data("api", "base_url") + one_testcase.url # 进行加标 res = self.do_request.send(one_testcase.method, new_url, json=new_data) # 获取响应数据并转化为字典类型 actual_value = res.json() try: self.assertEqual(one_testcase.expected_value, actual_value.get("errcode"), one_testcase.name) except AssertionError as e: do_log.error(f"{one_testcase.name}:具体异常为{e}") self.do_excel.write_data(one_testcase, res.text, "失败") raise e else: # if one_testcase.id == 2: # a.如果响应报文中含有token_info,说明当前用例为登录接口用例 # b.从响应报文中获取token,然后添加至请求头中 if "token" in res.text and one_testcase.id == 1: token = res.json()["data"]["token"] # add_headers需要传字典类型 headers = {"Authorization": "Bearer " + token} self.do_request.add_headers(headers) # check_sql_str = one_testcase.check_sql # if check_sql_str: # # 将check_sql json格式的字符串转化为字典 # check_sql_dict = json.loads(check_sql_str, encoding='utf-8') # if 'loan_id' in check_sql_dict: # # 获取查询loan id的sql语句 # loan_id_sql = check_sql_dict.get('loan_id') # # 将sql语句进行参数化 # loan_id_sql = Parameterize.to_parma(loan_id_sql) # mysql_data = self.do_mysql.get_one_value(sql=loan_id_sql) # # load_id = mysql_data['id'] # 获取loan_id # # 设置loan_id为GlobalData的类属性 # setattr(GlobalData, '${loan_id}', load_id) self.do_excel.write_data(one_testcase, res.text, "成功")
@Motto: ABC(Always Be Coding) @Email: [email protected] @Company: 湖南省零檬信息技术有限公司 @Copyright: 柠檬班 ------------------------------------------------- """ import os import unittest # from HTMLTestRunnerNew import HTMLTestRunner from libs.HTMLTestRunnerNew import HTMLTestRunner # from handle_yaml import do_yaml from scripts.handle_yaml import do_yaml from scripts.handle_path import CASES_PATH, REPORTS_PATH # suite = unittest.defaultTestLoader.discover(r"C:\Users\KeYou\PycharmProjects\TestApi0509\cases") suite = unittest.defaultTestLoader.discover(CASES_PATH) html_filename = do_yaml.get_data("report", "filename") # html_filename = r"C:\Users\KeYou\PycharmProjects\TestApi0509\reports" + "\\" + html_filename html_filename = os.path.join(REPORTS_PATH, html_filename) with open(html_filename, "wb") as file: runner = HTMLTestRunner(file, verbosity=do_yaml.get_data("report", "verbosity"), title=do_yaml.get_data("report", "title"), description=do_yaml.get_data( "report", "description"), tester=do_yaml.get_data("report", "tester")) runner.run(suite)
import json import requests from scripts.handle_yaml import do_yaml # 获取api版本信息 api_version = do_yaml.get_data("api", "api_version").get("X-Lemonban-Media-Type") if api_version == "lemonban.v3": # 如果为v3版本, 才导入HandleSign from scripts.handle_sign import HandleSign class HandleRequest: def __init__(self): # 创建会话对象 self.session = requests.Session() def send(self, method, url, **kwargs): """ 发送请求的方法 :param method: 请求方法 :param url: 请求url :param kwargs: headers请求头字典, data、json、files :return: """ one_method = method.upper() kwargs["json"] = self.handle_param("json", kwargs) kwargs["data"] = self.handle_param("data", kwargs) if hasattr(self, 'token'