Esempio n. 1
0
class HandleAssert:
    def __init__(self):
        self.sql_com_res = {}  # 存储sql查询之后的比较结果
        self.db = HandleDB()  # 打开数据库连接

    def assert_sql(self, check_sql_str):
        self.get_sql_comp_res(check_sql_str)
        # 关闭数据库连接
        self.db.close()

        if False in self.sql_com_res.values():
            logger.error("断言失败,数据库比对不成功!")
            raise AssertionError
        else:
            logger.info("数据库比对成功!")

    def get_sql_comp_res(self, check_sql_str):

        check_sql_dict = eval(check_sql_str)
        logger.info("数据库校验为:\n{}".format(check_sql_dict))

        if check_sql_dict["check_type"] == "value":
            logger.info("比较sql语句查询结果之后的值")
            sql_res = self.db.get_one(check_sql_dict["check_sql"])
            logger.info("执行sql:{}".format(check_sql_dict["check_sql"]))
            logger.info("查询结果:{}".format(sql_res))
            logger.info("预期结果为:{}".format(check_sql_dict["expected"]))

            # 执行的结果进行比较。sql_res为字典类型
            for key, value in check_sql_dict["expected"].items():
                if key in sql_res.keys():
                    if isinstance(sql_res[key], Decimal):
                        sql_res[key] = float(sql_res[key])
                        logger.info("将Decimal转换为float后的值:{}".format(sql_res[key]))
                    if value == sql_res[key]:
                        self.sql_com_res[key] = True  # 比较成功 存储到sql_com_res中
                        logger.info("比较成功!")
                    else:
                        self.sql_com_res[key] = False  # 比较失败 存储到sql_com_res中
                        logger.info("比较失败!")
                else:
                    logger.info("sql查询结果里面没有对应的列名{},请检查预期结果或查询语句是否正确}".format(key))
        # 比对slq语句查询之后的条数
        elif check_sql_dict["check_type"] == "count":
            logger.info("比较sql语句查询之后的条数,sql查询结果为整数,只要比对数字即可!")
            sql_res = self.db.get_count(check_sql_dict["check_sql"])
            logger.info("执行sql:{}".format(["check_sql"]))
            logger.info("查询结果:{}".format(sql_res))
            logger.info("预期结果为:{}".format(check_sql_dict["expected"]))
            # 比对
            if sql_res == check_sql_dict["expected"]:
                self.sql_com_res["count"] = True
                logger.info("比较成功!")
            else:
                self.sql_com_res["count"] = False
                logger.info("比较失败!")
Esempio n. 2
0
def get_new_phone():
    # 判断手机号是否已经注册,如果已经注册,重新生成新的手机号码
    while True:
        phone = __gen_phone()
        # 向数据库查询手机号是否已存在,如果查询结果为0,则为未注册,return退出循环
        hd = HandleDB()
        select_sql = f"select * from member where mobile_phone={phone};"
        count = hd.get_count(select_sql)
        if count == 0:
            hd.close()
            return phone
def new_phone():
    db = HandleDB()
    while True:

        phone = __get_phone()
        # 校验数据库
        count = db.get_sql(
            "select * from member where mobile_phone={}".format(phone))
        if count == 0:
            db.close()
            return phone
Esempio n. 4
0
 def setUpClass(cls):
     # 创建操作数据库的对象
     cls.db = HandleDB()
     # 登录,获取用户的id以及鉴权需要用到的token
     url = conf.get_str("env", "url") + "/member/login"
     data = {
         "mobile_phone": conf.get_str("test_data", 'user'),
         "pwd": conf.get_str("test_data", "pwd")
     }
     headers = eval(conf.get_str("env", "headers"))
     response = cls.http.send(url=url,
                              method="post",
                              json=data,
                              headers=headers)
     json_data = response.json()
     # -------登录之后,从响应结果中提取用户id和token-------------
     # 1、提取用户id
     member_id = jsonpath.jsonpath(json_data, "$..id")[0]
     setattr(TestData, "member_id", str(member_id))
     # 2、提取token
     token_type = jsonpath.jsonpath(json_data, "$..token_type")[0]
     token = jsonpath.jsonpath(json_data, "$..token")[0]
     setattr(TestData, "token", token)
     token_data = token_type + " " + token
     setattr(TestData, "token_data", token_data)
Esempio n. 5
0
class TestWithdraw(unittest.TestCase):
    excel = ReadExcel(data_file_path, "withdraw")
    cases = excel.read_data()
    http = HandleRequest()
    db = HandleDB()

    @data(*cases)
    def test_withdraw(self, case):
        # 第一步:准备测试用例数据
        url = conf.get_str("env", "url") + case["url"]
        data = eval(replace_data(case["data"]))
        method = case["method"]
        headers = eval(conf.get_str("env", "headers"))
        if case["interface"] != "login":
            headers["Authorization"] = getattr(TestData, "token_data")

        expected = eval(case["expected"])
        row = case["case_id"] + 1
        if case["check_sql"]:
            sql = replace_data(case["check_sql"])
            start_money = self.db.get_one(sql)[0]

        res = self.http.send(url=url,
                             method=method,
                             json=data,
                             headers=headers)
        result = res.json()
        if case["interface"] == "login":
            id = jsonpath.jsonpath(result, "$..id")[0]
            setattr(TestData, "member_id", str(id))
            token_type = jsonpath.jsonpath(result, "$..token_type")[0]
            token = jsonpath.jsonpath(result, "$..token")[0]
            token_data = token_type + " " + token
            setattr(TestData, "token", token)

        try:
            self.assertEqual(expected["code"], result["code"])
            self.assertEqual(expected["msg"], result["msg"])
            if case["check_sql"]:
                sql = replace_data(case["check_sql"])
                end_money = self.db.get_one(sql)[0]
                withdraw_money = decimal.Decimal(str(data["amount"]))
                my_log.info("取现之前金额为:{}\n取现金额为:{}\n取现之后金额为:{}".format(
                    start_money, withdraw_money, end_money))
                self.assertEqual(withdraw_money, start_money - end_money)

        except AssertionError as e:
            self.excel.write_data(row=row, column=8, value="未通过")
            my_log.info("用例:{}---->执行未通过".format(case["title"]))
            print("预期结果:{}".format(expected))
            print("实际结果:{}".format(result))
            raise e
        else:
            self.excel.write_data(row=row, column=8, value="通过")
            my_log.info("用例:{}---->执行未通过".format(case["title"]))
Esempio n. 6
0
class TestAdd(unittest.TestCase):
    excel = ReadExcel(file_path, "add")
    cases = excel.read_data()
    http = HandleRequest()
    db = HandleDB()

    @data(*cases)
    def test_add(self, case):
        # 第一步:准备用例数据
        # 获取url
        url = conf.get_str("env", "url") + case["url"]
        # 获取数据
        case["data"] = replace_data(case["data"])
        data = eval(case["data"])
        # 请求头
        headers = eval(conf.get_str("env", "headers"))
        if case["interface"] != "login":
            headers["Authorization"] = getattr(TestData, "token_data")
        # 预期结果
        expected = eval(case["expected"])
        # 请求方法
        method = case["method"]
        # 用例所在的行
        row = case["case_id"] + 1
        # 第二步:发送请求
        print(url, method, data, headers)
        res = self.http.send(url=url,
                             method=method,
                             json=data,
                             headers=headers)
        json_data = res.json()
        print("json_data=", json_data)
        if case["interface"] == "login":
            # 如果是登录的用例,提取对应的token,和用户id,保存为TestData这个类的类属性,用来给后面的用例替换
            token_type = jsonpath.jsonpath(json_data, "$..token_type")[0]
            token = jsonpath.jsonpath(json_data, "$..token")[0]
            token_data = token_type + " " + token
            setattr(TestData, "token_data", token_data)
            id = jsonpath.jsonpath(json_data, "$..id")[0]
            setattr(TestData, "admin_member_id", str(id))
        # 第三步:断言
        try:
            self.assertEqual(expected["code"], json_data["code"])
            self.assertEqual(expected["msg"], json_data["msg"])

        except AssertionError as e:
            self.excel.write_data(row=row, column=8, value="未通过")
            my_log.info("用例:{}--->执行未通过".format(case["title"]))
            print("预取结果:{}".format(expected))
            print("实际结果:{}".format(json_data))
            raise e
        else:
            self.excel.write_data(row=row, column=8, value="通过")
            my_log.info("用例:{}--->执行通过".format(case["title"]))
Esempio n. 7
0
class TestAdd(unittest.TestCase):
    excel = ReadExcel(file_path, "add")
    cases = excel.read_data()
    http = HandleRequest()
    db = HandleDB()

    @data(*cases)
    def test_add(self, case):
        # 第一步:准备用例数据
        url = conf.get_str("env", "url") + case["url"]
        case["data"] = replace_data(case["data"])
        data = eval(case["data"])
        headers = eval(conf.get_str("env", "headers"))
        if case["interface"] != "login":
            headers["Authorization"] = getattr(TestData, "token_data")
        expected = eval(case["expected"])
        method = case["method"]
        row = case["case_id"] + 1
        # 第二步:发送请求
        if case["check_sql"]:
            sql = replace_data(case["check_sql"])
            s_loan_num = self.db.count(sql)
        res = self.http.send(url=url,
                             method=method,
                             json=data,
                             headers=headers)
        result = res.json()
        if case["interface"] == "login":
            token_type = jsonpath.jsonpath(result, "$..token_type")[0]
            token = jsonpath.jsonpath(result, "$..token")[0]
            token_data = token_type + " " + token
            setattr(TestData, "token_data", token_data)
            id = jsonpath.jsonpath(result, "$..id")[0]
            setattr(TestData, "admin_member_id", str(id))
        # 第三步:比对结果(断言)
        try:
            self.assertEqual(expected["code"], result["code"])
            self.assertEqual(expected["msg"], result["msg"])
            if case["check_sql"]:
                sql = replace_data(case["check_sql"])
                end_loan_num = self.db.count(sql)
                self.assertEqual(end_loan_num - s_loan_num, 1)

        except AssertionError as e:
            self.excel.write_data(row=row, column=8, value="未通过")
            my_log.info("用例:{}---->执行未通过".format(case["title"]))
            print("预期结果:{}".format(expected))
            print("实际结果:{}".format(result))
            raise e
        else:
            self.excel.write_data(row=row, column=8, value="通过")
            my_log.info("用例:{}---->执行未通过".format(case["title"]))
Esempio n. 8
0
class TestAdd(unittest.TestCase):
    excel = ReadExcel(data_file_path, "add")
    # 读取数据
    test_data = excel.read_excel()
    # # 创建http对象
    http = HandleRequest()
    #创建db对象
    db = HandleDB()

    @data(*test_data)
    def test_add(self, test_data_cases):
        # 第一步:准备用例数据
        # (1)获取url
        url = conf.get_str("env", "url_ip") + test_data_cases["url"]
        # (2)获取数据
        test_data_cases["data"] = replace_data(
            test_data_cases["data"])  # 调用replace_data方法
        # (3)数据转换
        data = eval(test_data_cases["data"])
        # (4)预期结果
        expected = eval(test_data_cases["expected"])  # excel是字典类型,需要转换一下
        # (5)请求方法
        method = test_data_cases["method"]
        # (6)用例所在的行
        row = test_data_cases["case_id"] + 1
        # (7)请求头
        headers = eval(conf.get_str("env", "headers"))
        if test_data_cases["interface"] != "login":
            # 如果不是token,需要添加请求头
            headers["Authorization"] = getattr(TestData,
                                               "token_data")  # 调用保存在临时变量的类中
        #先判断check_sql是否有数据
        if test_data_cases["check_sql"]:
            sql = replace_data(
                test_data_cases["check_sql"])  #先获取check_sql数据,在进行替换
            #执行sql语句
            s_loan_num = self.db.count(sql)  #得到加标前项目的条数

        # 第二步:发送请求到接口,获取实际结果
        res = self.http.send(url=url,
                             method=method,
                             json=data,
                             headers=headers)
        result = res.json()

        # 判断是否是登录用例,是的话,则提取token
        if test_data_cases["interface"] == "login":
            # 如果是登录的用例,提取对应的token
            token_type = jsonpath.jsonpath(result, "$..token_type")[0]
            token = jsonpath.jsonpath(result, "$..token")[0]
            token_data = token_type + " " + token
            # 通过setattr方法保存到TestData类里面
            setattr(TestData, "token_data", token_data)
            # 提取member_id
            admin_member_id = jsonpath.jsonpath(result, "$..id")[0]
            # 通过setattr方法保存到TestData类里面
            setattr(TestData, "admin_member_id",
                    str(admin_member_id))  # 存类属性的时候,需要与excel中的参数名一致

        # 第三步:比对预期结果和实际结果
        try:
            self.assertEqual(expected["code"], result["code"])
            self.assertEqual(expected["msg"], result["msg"])
            # 加标后,项目的条数
            # 先判断check_sql是否有数据
            if test_data_cases["check_sql"]:
                sql = replace_data(
                    test_data_cases["check_sql"])  # 先获取check_sql数据,在进行替换
                # 执行sql语句
                end_loan_num = self.db.count(sql)  # 得到加标前项目的条数
                self.assertEqual(end_loan_num - s_loan_num, 1)
        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"]))
Esempio n. 9
0
class TestAdd(unittest.TestCase):
    excel = ReadExcel(file_path, "add")
    cases = excel.read_data()
    http = HandleRequest()
    db = HandleDB()

    @data(*cases)
    def test_add(self, case):
        #--------------第一步:准备用例数据-----------------
        #1.获取url
        url = conf.get_str("env", "url") + case["url"]
        #2.获取数据
        case["data"] = replace_data(case["data"])
        data = eval(case["data"])
        #3.获取请求头
        headers = eval(conf.get_str("env", "headers"))
        if case["interface"] != "login":
            headers["Authorization"] = getattr(TestData, "token_data")
        #预期结果
        expected = eval(case["expected"])
        #请求方法
        method = case["method"]
        print(method, type(method))
        #用例所在行
        row = case["case_id"] + 1

        #----------------第二步:发送请求---------------------
        if case["check_sql"]:
            sql = replace_data(case["check_sql"])
            s_loan_num = self.db.count(sql)
        res = self.http.send(url=url,
                             method=method,
                             json=data,
                             headers=headers)
        json_data = res.json()
        if case["interface"] == "login":
            # 如果是登录的用例,提取对应的token,和用户id,保存为TestData这个类的类属性,用来给后面的用例替换
            token_type = jsonpath.jsonpath(json_data, "$..token_type")[0]
            token = jsonpath.jsonpath(json_data, "$..token")[0]
            token_data = token_type + " " + token
            setattr(TestData, "token_data", token_data)
            id = jsonpath.jsonpath(json_data, "$..id")[0]
            setattr(TestData, "admin_member_id", str(id))
        '''补充知识:
               setattr() 函数对应函数 getattr(),用于设置属性值,该属性不一定是存在的。
               setattr(object, name, value),有就用新的属性值替换掉原来的,没有就自动创建一个属性值
               >>>class A(object):
               >>> bar = 1
               >>> a = A()
               >>> getattr(a, 'bar')          # 获取属性 bar 值
                    1
               >>> setattr(a, 'bar', 5)       # 设置属性 bar 值
               >>> a.bar
                    5
       '''
        #----------------第三步:断言-------------------------------
        try:
            self.assertEqual(expected["code"], json_data["code"])
            self.assertEqual(expected["msg"], json_data["msg"])
            # 判断是否需要sql校验
            if case["check_sql"]:
                sql = replace_data(case["check_sql"])
                end_loan_num = self.db.count(sql)
                self.assertEqual(end_loan_num - s_loan_num, 1)

        except AssertionError as e:
            self.excel.write_data(row=row, column=8, value="未通过")
            my_log.info("用例:{}--->执行未通过".format(case["title"]))
            print("预取结果:{}".format(expected))
            print("实际结果:{}".format(json_data))
            raise e
        else:
            self.excel.write_data(row=row, column=8, value="通过")
            my_log.info("用例:{}--->执行通过".format(case["title"]))
class TestRecharge(unittest.TestCase):
    # 通过类创建excel对象
    excel = ReadExcel(data_file_path, "recharge")
    # 读取数据
    test_data = excel.read_excel()
    http = HandleRequest()
    # 创建DB对象
    db = HandleDB()

    @classmethod
    def setUpClass(cls):  # 在测试用例类(TestRecharge)执行之前就会执行这个方法
        # 登录:获取用户的id以及鉴权需要用到的token
        url = conf.get_str("env", "url_ip") + "/member/login"
        login_data = {"mobile_phone": user, "pwd": pwd}
        headers = eval(conf.get_str("env", "headers"))
        response = cls.http.send(
            url=url, method="post", json=login_data,
            headers=headers)  # 此处用cls是因为是类方法setUpClass(cls)里面的,是通过类属性去调用的
        result = response.json()
        # 登录之后,从响应结果中提取用户id和token
        # (1)获取用户id
        # cls.member_id = str(jsonpath.jsonpath(result, "$..id")[0])#设置为TestRecharge类的类属性

        member_id = jsonpath.jsonpath(result, "$..id")[0]  # 获取member_id
        print(member_id)
        # 设置TestData类的类属性
        setattr(
            TestData, "member_id",
            str(member_id))  #设置TestData类的类属性,设置类属性为member_id,类属性的值为member_id
        # (2)提取token
        token_type = jsonpath.jsonpath(result, "$..token_type")[0]
        token = jsonpath.jsonpath(result, "$..token")[0]
        # cls.token_data = token_type + " " + token#设置为TestRecharge类的类属性
        token_data = token_type + " " + token  #
        setattr(
            TestData, "token_data",
            token_data)  # 设置TestData类的类属性,设置类属性为token_data,类属性的值为token_data

    # def setUp(self):#每个用例执行之前都会执行
    # 如果把登录放在这里,每执行完一个用例就会登录,增加代码的运行时间,没有必要
    @data(*test_data)  # 进行解包
    def test_recharge(self, test_data_cases):
        # 第一步:准备用例数据
        # 备注:列表、字典方式存储的,excel读取出来是字符串。数值类型,读取出来是数值类型的,字符串类型,读取出来是字符串类型。
        # ①拼接完整的接口地址
        url = conf.get_str("env", "url_ip") + test_data_cases["url"]
        # ②请求的方法
        method = test_data_cases["method"]

        # ③请求参数
        # 判断是否有用户id需要替换
        # if "#member_id#" in test_data_cases["data"]:
        #     # 进行替换
        #     test_data_cases["data"] = test_data_cases["data"].replace("#member_id#",
        #                                                               self.member_id)  # 替换完后需要接收,不然没有实质的替换
        test_data_cases["data"] = replace_data(
            test_data_cases["data"])  #调用replace_data方法
        data = eval(test_data_cases["data"])

        # ④请求头
        headers = eval(conf.get_str("env", "headers"))
        # 添加鉴权
        # headers["Authorization"] = self.token_data
        # 从TestData类里面获取token_data属性:两种方法
        # headers["Authorization"] = TestData.token_data#方法一:直接从TestData类里面获取token_data属性
        headers["Authorization"] = getattr(
            TestData, "token_data")  # 方法二:用getattr获取TestData类里面获取token_data属性
        # ⑤预期结果
        expected = eval(test_data_cases["expected"])
        # ⑥该用例在表单中所在行
        row = test_data_cases["case_id"] + 1

        # 第二步:发送请求到接口,获取实际结果
        if test_data_cases[
                "check_sql"]:  # 先判断用例里面check_sql字段是否有数据,如果有数据,说明需要进行数据库校验
            sql = test_data_cases["check_sql"].format(user)
            # 获取充值之前的余额
            start_money = self.db.get_one(sql)[0]

        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 test_data_cases["check_sql"]:
                sql = test_data_cases["check_sql"].format(user)
                # 获取充值之后的余额
                end_money = self.db.get_one(sql)[0]
                # 获取请求参数里面的充值金额
                recharge_money = decimal.Decimal(str(data["amount"]))
                my_log.info("充值之前金额为:{}\n,充值金额为:{}\n,充值之后金额为:{}\n".format(
                    start_money, recharge_money, end_money))
                # 进行断言
                self.assertEqual(recharge_money, end_money - start_money)
        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"]))
Esempio n. 11
0
'''
作者:seak
时间:
项目:
题目:
作用:
备注:
'''
import decimal

from common.handle_db import HandleDB
from common.myconfig import conf

#调用数据库控制类
db = HandleDB()
#输入查询语句
sql = 'SELECT leave_amount FROM futureloan.member WHERE mobile_phone="{}"'
#调用配置文件中user的手机号码
phone = conf.get_str("test_data", 'user')

#获取这个电话号码所拥有的金额,格式化sql语句
s_amount = db.get_one(sql.format(phone))[0]
print(s_amount, type(s_amount))

#decimal的类型不能与float相加,所以要进行转化,将其他数据转化为decimal问题,转化之前线转化成字符串否者会有精度问题
amount = 100.1
amount = decimal.Decimal(str(amount))
all_amount = s_amount + amount
print(all_amount)
Esempio n. 12
0
 def __init__(self):
     self.sql_com_res = {}  # 存储sql查询之后的比较结果
     self.db = HandleDB()  # 打开数据库连接
Esempio n. 13
0
class TestRegister(unittest.TestCase):
    excel = ReadExcel(data_file_path,"register")
    cases = excel.read_data()
    http = HandleRequest()
    db = HandleDB()
    @data(*cases)
    def test_register(self,case):
        # 第一步:准备测试用例数据
        # 拼接完整的接口地址
        url = conf.get_str("env", "url") + case["url"]
        # 请求方法
        method = case["method"]
        # 请求参数
        # 判断是否有手机号码需要替换
        if "#phone#" in case["data"]:
            while True:
                phone = self.random_phone()
                sql = "SELECT * FROM futureloan.member where mobile_phone={}".format(phone)
                count = self.db.count(sql)
                if count != 1:
                    break

            case["data"] = case["data"].replace("#phone#",phone)

        data = eval(case["data"])
        # 请求头
        headers = eval(conf.get_str("env", "headers"))
        # 预期结果
        expected = eval(case["expected"])
        # 该用例在该表单中所在行
        row = case["case_id"] + 1

        # 第二步:发送请求到接口,获取实际结果
        response = self.http.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)
                # 获取数据库中有没有该用户的信息
                count = self.db.count(sql)

                self.assertEqual(1,count)

        except AssertionError as e:
            self.excel.write_data(row=row, column=8, value="未通过")
            my_log.info("用例:{}---->执行未通过".format(case["title"]))
            print("预期结果:{}".format(expected))
            print("实际结果:{}".format(result))
            raise e
        else:
            self.excel.write_data(row=row, column=8, value="通过")
            my_log.info("用例:{}---->执行未通过".format(case["title"]))

    @staticmethod
    def random_phone():
        phone = "133"
        for i in range(8):
            phone += str(random.randint(0, 9))
        return phone

    @classmethod
    def tearDownClass(cls):
        # 关闭数据的连接和游标对象
        cls.db.close()
Esempio n. 14
0
class TestRegister(unittest.TestCase):
    excel = ReadExcel(data_file_path, "register")
    cases = excel.read_data()
    http = HandleRequest()
    db = HandleDB()

    @data(*cases)
    def test_register(self, case):
        # ------第一步:准备用例数据------------
        # 拼接完整的接口地址
        url = conf.get_str("env", "url") + case["url"]
        # 请求的方法
        method = case["method"]

        # 请求参数
        # 判断是否有有手机号码需要替换
        if "#phone#" in case["data"]:
            # 生成一个手机号码
            phone = self.random_phone()
            # 进行替换
            case["data"] = case["data"].replace("#phone#", phone)

        data = eval(case["data"])
        # 请求头
        headers = eval(conf.get_str("env", "headers"))
        # 预期结果
        expected = eval(case["expected"])
        # 该用例在表单的中所在行
        row = case["case_id"] + 1

        # ------第二步:发送请求到接口,获取实际结果--------
        response = self.http.send(url=url, method=method, json=data, headers=headers)
        result = response.json()
        # --------------------以下内容为扩展内容----------------
        # 先判断是否注册成功,如果是注册成功
        # self.phone = "注册成功的手机号码"  # 没有注册成功就设置未None
        # ---------------------------------------------------

        # -------第三步:比对预期结果和实际结果-----
        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)
                # 获取数据库中没有没有该用户的信息
                count = self.db.count(sql)
                # 数据库中返回的数据做断言,判断是否有一条数据
                self.assertEqual(1, count)

        except AssertionError as e:
            self.excel.write_data(row=row, column=8, value="未通过")
            my_log.info("用例:{}--->执行未通过".format(case["title"]))
            print("预取结果:{}".format(expected))
            print("实际结果:{}".format(result))
            raise e
        else:
            self.excel.write_data(row=row, column=8, value="通过")
            my_log.info("用例:{}--->执行通过".format(case["title"]))

    @staticmethod
    def random_phone():
        """生成随机的手机号码"""
        phone = "133"
        for i in range(8):
            phone += str(random.randint(0, 9))

        return phone

    @classmethod
    def tearDownClass(cls):
        # 关闭数据的连接和游标对象
        cls.db.close()
Esempio n. 15
0
class TestAudit(unittest.TestCase):
    excel = ReadExcel(file_path, "audit")
    cases = excel.read_data()
    http = HandleRequest()
    db = HandleDB()

    @classmethod
    def setUpClass(cls):
        # -----------执行用例之前先进行登录-->
        # 登录,获取用户的id以及鉴权需要用到的token
        url = conf.get_str("env", "url") + "/member/login"
        data = {
            "mobile_phone": conf.get_str("test_data", 'admin_phone'),
            "pwd": conf.get_str("test_data", "admin_pwd")
        }
        headers = eval(conf.get_str("env", "headers"))
        response = cls.http.send(url=url, method="post", json=data, headers=headers)
        json_data = response.json()
        # -------登录之后,从响应结果中提取用户id和token-------------
        # 1、提取用户id
        member_id = jsonpath.jsonpath(json_data, "$..id")[0]
        setattr(TestData, "member_id", str(member_id))
        # 2、提取token
        token_type = jsonpath.jsonpath(json_data, "$..token_type")[0]
        token = jsonpath.jsonpath(json_data, "$..token")[0]
        setattr(TestData, "token", token)
        token_data = token_type + " " + token
        setattr(TestData, "token_data", token_data)

    def setUp(self):
        # ---------每个审核的用例执行之前都加一个项目,将项目id保存起来----------
        url = conf.get_str("env", "url") + "/loan/add"
        data = {"member_id": getattr(TestData, "member_id"),
                "title": "借钱实现财富自由",
                "amount": 2000,
                "loan_rate": 12.0,
                "loan_term": 3,
                "loan_date_type": 1,
                "bidding_days": 5}
        # 获取sign和时间戳
        sign_data = HandleSign.generate_sign(getattr(TestData, "token"))
        # 将sign加入到请求参数中
        data.update(sign_data)
        headers = eval(conf.get_str("env", "headers"))
        headers["Authorization"] = getattr(TestData, "token_data")
        # 发送请求加标
        response = self.http.send(url=url, method="post", json=data, headers=headers)
        json_data = response.json()
        # 1、提取标id
        loan_id = jsonpath.jsonpath(json_data, "$..id")[0]
        # 2、保存为TestDate的属性
        setattr(TestData, "loan_id", str(loan_id))

    @data(*cases)
    def test_audit(self, case):
        # 拼接完整的接口地址
        url = conf.get_str("env", "url") + case["url"]
        # 请求的方法
        method = case["method"]
        # 请求参数
        # 替换用例参数
        case["data.txt"] = replace_data(case["data.txt"])
        data = eval(case["data.txt"])
        # 获取sign和时间戳
        sign_data = HandleSign.generate_sign(getattr(TestData, "token"))
        # 将sign加入到请求参数中
        data.update(sign_data)
        # 请求头
        headers = eval(conf.get_str("env", "headers"))
        headers["Authorization"] = getattr(TestData, "token_data")

        # 预期结果
        expected = eval(case["expected"])
        # 该用例在表单的中所在行
        row = case["case_id"] + 1

        # ------第二步:发送请求到接口,获取实际结果--------
        response = self.http.send(url=url, method=method, json=data, headers=headers)
        result = response.json()
        # 如果审核通过的项目返回ok,说明该项目已审核
        if case["title"] == "审核通过" and result["msg"] == "OK":
            pass_loan_id = getattr(TestData, "loan_id")
            # 将该项目的id保存起来
            setattr(TestData, "pass_loan_id", pass_loan_id)

        # -------第三步:比对预期结果和实际结果-----
        try:
            self.assertEqual(expected["code"], result["code"])
            self.assertEqual((expected["msg"]), result["msg"])
            if case["check_sql"]:
                sql = replace_data(case["check_sql"])
                # 获取这个标的用户id
                status = self.db.get_one(sql)[0]
                # 进行断言
                self.assertEqual(expected["status"], status)
        except AssertionError as e:
            self.excel.write_data(row=row, column=8, value="未通过")
            my_log.info("用例:{}--->执行未通过".format(case["title"]))
            print("预取结果:{}".format(expected))
            print("实际结果:{}".format(result))
            raise e
        else:
            self.excel.write_data(row=row, column=8, value="通过")
            my_log.info("用例:{}--->执行通过".format(case["title"]))
class TestInvest(unittest.TestCase):
    excel = ReadExcel(data_file_path, "invest")
    cases = excel.read_data()
    http = HandleRequest()
    db = HandleDB()

    @data(*cases)
    def test_invest(self, case):
        # 第一步:准备用例数据
        # 获取URL
        url = conf.get_str("env", "url") + case["url"]
        # 获取请求的方法
        method = case["method"]
        # 获取请求的参数
        # 替换用例参数
        case["data"] = replace_data(case["data"])
        data = eval(case["data"])
        # 获取请求头
        headers = eval(conf.get_str("env", "headers"))
        if case["interface"] != "login":
            headers["Authorization"] = getattr(TestData, "token_data")
            # 添加请求头中的token
        # 预期结果
        expected = eval(case["expected"])
        # 获取所在行
        row = case["case_id"] + 1
        # ------第二步:发送请求到接口,获取实际结果--------
        response = self.http.send(url=url,
                                  method=method,
                                  headers=headers,
                                  json=data)
        result = response.json()
        if case["interface"] == "login":
            # 提取用户id和token
            id = jsonpath.jsonpath(result, "$..id")[0]
            token_type = jsonpath.jsonpath(result, "$..token_type")[0]
            token = jsonpath.jsonpath(result, "$..token")[0]
            token_data = token_type + " " + token
            setattr(TestData, "token_data", token_data)
            setattr(TestData, "member_id", str(id))

        elif case["interface"] == "add":
            # 提取项目id
            loan_id = jsonpath.jsonpath(result, "$..id")[0]
            setattr(TestData, "loan_id", str(loan_id))
        #  -------第三步:比对预期结果和实际结果-----
        try:
            self.assertEqual(expected["code"], result["code"])
            self.assertEqual(expected["msg"], result["msg"])
            # 判断是否需要sql校验
            if case["check_sql"]:
                sql = replace_data(case["check_sql"])
                count = self.db.count(sql)[0]
                # 判断数据库表中是否有一条新数据
                self.assertEqual(1, count)

        except AssertionError as e:
            self.excel.write_data(row=row, column=8, value="未通过")
            my_log.info("用例:{}--->执行未通过".format(case["title"]))
            raise e

        else:
            self.excel.write_data(row=row, column=8, value="通过")
            my_log.info(my_log.info("用例:{}--->执行通过".format(case["title"])))
Esempio n. 17
0
 def setUp(cls) -> None:
     cls.hr = HandleRequests()
     cls.hd = HandleDB()
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()
Esempio n. 19
0
class TestRecharge(unittest.TestCase):
    excel = ReadExcel(data_file_path, "recharge")
    cases = excel.read_data()
    http = HandleRequest()
    db = HandleDB()

    @classmethod
    def setUpClass(cls):
        # # 创建操作数据库的对象
        # cls.db = HandleDB()
        # 登录,获取用户的id以及鉴权需要用到的token
        url = conf.get_str("env", "url") + "/member/login"
        data = {
            "mobile_phone": conf.get_str("test_data", 'user'),
            "pwd": conf.get_str("test_data", "pwd")
        }
        headers = eval(conf.get_str("env", "headers"))
        response = cls.http.send(url=url,
                                 method="post",
                                 json=data,
                                 headers=headers)
        json_data = response.json()
        # -------登录之后,从响应结果中提取用户id和token-------------
        # 1、用户id
        member_id = jsonpath.jsonpath(json_data, "$..id")[0]
        setattr(TestData, "member_id", str(member_id))
        # 2、提取token
        token_type = jsonpath.jsonpath(json_data, "$..token_type")[0]
        token = jsonpath.jsonpath(json_data, "$..token")[0]
        token_data = token_type + " " + token
        setattr(TestData, "token_data", token_data)

    @data(*cases)
    def test_recharge(self, case):
        # ------第一步:准备用例数据------------
        # 拼接完整的接口地址
        url = conf.get_str("env", "url") + case["url"]
        # 请求的方法
        method = case["method"]
        # 请求参数
        # 替换用例参数
        case["data"] = replace_data(case["data"])

        data = eval(case["data"])
        # 请求头
        headers = eval(conf.get_str("env", "headers"))
        headers["Authorization"] = getattr(TestData, "token_data")

        # 预期结果
        expected = eval(case["expected"])
        # 该用例在表单的中所在行
        row = case["case_id"] + 1

        # ------第二步:发送请求到接口,获取实际结果--------

        if case["check_sql"]:
            sql = case["check_sql"].format(conf.get_str("test_data", "user"))
            # 获取充值之前的余额
            start_money = self.db.get_one(sql)[0]

        response = self.http.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 case["check_sql"]:
                sql = case["check_sql"].format(
                    conf.get_str("test_data", "user"))
                # 获取充值之后的余额
                end_money = self.db.get_one(sql)[0]
                # 充值的金额
                recharge_money = decimal.Decimal(str(data["amount"]))
                my_log.info("充值之前金额为{}\n,充值金额:{}\n,充值之后金额为{},".format(
                    start_money, recharge_money, end_money))
                # 数据库中返回的数据做断言,判断是否有一条数据
                self.assertEqual(recharge_money, end_money - start_money)

        except AssertionError as e:
            self.excel.write_data(row=row, column=8, value="未通过")
            my_log.info("用例:{}--->执行未通过".format(case["title"]))
            print("预取结果:{}".format(expected))
            print("实际结果:{}".format(result))
            raise e
        else:
            self.excel.write_data(row=row, column=8, value="通过")
            my_log.info("用例:{}--->执行通过".format(case["title"]))

    @classmethod
    def tearDownClass(cls):
        # 关闭数据的连接和游标对象
        cls.db.close()
Esempio n. 20
0
class TestRecharge(unittest.TestCase):
    excel = ReadExcel(data_file_path,"recharge")
    cases = excel.read_data()
    http = HandleRequest()
    db = HandleDB()

    @classmethod
    def setUpClass(cls):
         # 登录,获取用户id和鉴权需要用到的token
        url = conf.get_str("env", "url") + "/member/login"
        data = {
            "mobile_phone":conf.get_str("test_data","user"),
            "pwd":conf.get_str("test_data","pwd")
        }
        headers = eval(conf.get_str("env","headers"))
        response = cls.http.send(url=url,method="post",json=data,headers=headers)
        json_data = response.json()
        #  登录之后从响应结果中提取用户id和token
        # 提取用户id
        cls.member_id = jsonpath.jsonpath(json_data,"$..id")[0]
        # 提取token
        token_type = jsonpath.jsonpath(json_data,"$..token_type")[0]
        token = jsonpath.jsonpath(json_data,"$..token")[0]
        cls.token_data = token_type + " " + token
        cls.leave_amount = jsonpath.jsonpath(json_data,"$..leave_amount")[0]


    @data(*cases)
    def test_recharge(self,case):
        # 第一步:准备测试用例数据
        # 拼接完整的接口地址
        url = conf.get_str("env", "url") + case["url"]
        # 请求方法
        method = case["method"]
        # 请求参数
        # 判断是否有用户id需要替换
        if "#member_id#" in case["data"]:
            case["data"] = case["data"].replace("#member_id#",str(self.member_id))

        data = eval(case["data"])
        # 请求头
        headers = eval(conf.get_str("env", "headers"))
        headers["Authorization"] = self.token_data
        # 预期结果
        expected = eval(case["expected"])
        # 该用例在该表单中所在行
        row = case["case_id"] + 1

        # 第二步:发送请求到接口,获取实际结果
        response = self.http.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 leave_amount from futureloan.member where id={}".format(self.member_id)
                # 获取数据库中有没有该用户的信息
                data = self.db.get_one(sql)
                print(data)


                # self.assertEqual(1, count)
        except AssertionError as e:
            self.excel.write_data(row=row, column=8, value="未通过")
            my_log.info("用例:{}---->执行未通过".format(case["title"]))
            print("预期结果:{}".format(expected))
            print("实际结果:{}".format(result))
            raise e
        else:
            self.excel.write_data(row=row, column=8, value="通过")
            my_log.info("用例:{}---->执行未通过".format(case["title"]))
class TestWithdraw(unittest.TestCase):
    excel = ReadExcel(data_file_path, "withdraw")
    cases = excel.read_data()
    http = HandleRequest()
    db = HandleDB()

    @classmethod
    def setUpClass(cls):
        # 获取登录用户手机号和密码
        # cls.mobile_phone = conf.get_str("test_data", 'user')
        # cls.pwd = conf.get_str("test_data", "pwd")
        pass

    @data(*cases)
    def test_withdraw(self, case):
        # ------第一步:准备用例数据------------
        # 拼接完整的接口地址
        url = conf.get_str("env", "url") + case["url"]
        # 请求的方法
        method = case["method"]
        # 请求参数
        # 判断是否有用户id需要替换
        case["data"] = replace_data(case["data"])
        data = eval(case["data"])

        # 请求头
        headers = eval(conf.get_str("env", "headers"))
        if case["interface"] != "login":
            headers["Authorization"] = getattr(TestData, "token_data")
        # 预期结果
        expected = eval(case["expected"])
        # 该用例在表单的中所在行
        row = case["case_id"] + 1

        # ------第二步:发送请求到接口,获取实际结果--------
        # 判断是否需要sql校验
        if case["check_sql"]:
            sql = case["check_sql"].format(conf.get_str("test_data", 'user'))
            # 获取取充值之前的余额
            start_money = self.db.get_one(sql)[0]
        # 发送请求,获取结果
        response = self.http.send(url=url,
                                  method=method,
                                  json=data,
                                  headers=headers)
        result = response.json()

        if case["interface"] == "login":
            # -------如果是登录接口,从响应结果中提取用户id和token-------------
            # 1、用户id
            member_id = jsonpath.jsonpath(result, "$..id")[0]
            setattr(TestData, "member_id", str(member_id))

            # 2、提取token
            token_type = jsonpath.jsonpath(result, "$..token_type")[0]

            token = jsonpath.jsonpath(result, "$..token")[0]
            token_data = token_type + " " + token

            # 下面这行代码和上面哪行代码是一个意思,都是将token设为类属性

            setattr(TestData, "token_data", token_data)
        # -------第三步:比对预期结果和实际结果-----
        try:
            self.assertEqual(expected["code"], result["code"])
            self.assertEqual((expected["msg"]), result["msg"])
            # 判断是否需要数据库校验
            if case["check_sql"]:
                sql = case["check_sql"].format(
                    conf.get_str("test_data", 'user'))
                # 获取取充值之前的余额
                end_money = self.db.get_one(sql)[0]
                recharge_money = decimal.Decimal(str(data["amount"]))
                my_log.info("取现之前金额为{}\n,取现金额为:{}\n,取现之后金额为{},".format(
                    start_money, recharge_money, end_money))
                # 进行断言(开始的金额减去结束的金额)
                self.assertEqual(recharge_money, start_money - end_money)

        except AssertionError as e:
            self.excel.write_data(row=row, column=8, value="未通过")
            my_log.info("用例:{}--->执行未通过".format(case["title"]))
            print("预取结果:{}".format(expected))
            print("实际结果:{}".format(result))
            raise e
        else:
            self.excel.write_data(row=row, column=8, value="通过")
            my_log.info("用例:{}--->执行通过".format(case["title"]))
Esempio n. 22
0
class TestWithdraw(unittest.TestCase):
    # 通过类创建excel对象
    excel = ReadExcel(data_file_path, "withdraw")
    # 读取数据
    test_data = excel.read_excel()
    http = HandleRequest()
    db = HandleDB()

    @classmethod
    def setUpClass(cls):  # 在测试用例类(TestRecharge)执行之前就会执行这个方法
        # # 获取登录用户手机号和密码:并保存为类属性
        # cls.mobile_phone = conf.get_str("test_data", "user")
        # cls.pwd = conf.get_str("test_data", "pwd")
        pass

    # def setUp(self):#每个用例执行之前都会执行
    # 如果把登录放在这里,每执行完一个用例就会登录,增加代码的运行时间,没有必要
    @data(*test_data)  # 进行解包
    def test_withdraw(self, test_data_cases):
        # 第一步:准备用例数据
        # 备注:列表、字典方式存储的,excel读取出来是字符串。数值类型,读取出来是数值类型的,字符串类型,读取出来是字符串类型。
        # ①拼接完整的接口地址
        url = conf.get_str("env", "url_ip") + test_data_cases["url"]
        # ②请求的方法
        method = test_data_cases["method"]

        # ③请求参数
        #调用replace_data方法进行参数替换
        test_data_cases["data"] = replace_data(test_data_cases["data"])
        data = eval(test_data_cases["data"])
        # ④请求头
        headers = eval(conf.get_str("env", "headers"))
        # 添加鉴权
        # 判断是否为登录接口,不是登录接口,则需要加token值
        if test_data_cases["interface"] != "login":
            # headers["Authorization"] = self.token_data
            headers["Authorization"] = getattr(TestData, "token_data")
        # ⑤预期结果
        expected = eval(test_data_cases["expected"])
        # ⑥该用例在表单中所在行
        row = test_data_cases["case_id"] + 1

        # 第二步:发送请求到接口,获取实际结果
        if test_data_cases[
                "check_sql"]:  # 先判断用例里面check_sql字段是否有数据,如果有数据,说明需要进行数据库校验
            sql = test_data_cases["check_sql"].format(
                conf.get_str("test_data", "user"))
            # 获取充值之前的余额
            start_money = self.db.get_one(sql)[0]
        response = HandleRequest().send(url=url,
                                        method=method,
                                        json=data,
                                        headers=headers)
        result = response.json()
        # 判断是否是登录的用例,如果是登录接口,则去获取用户的id,并设置为类属性
        if test_data_cases["interface"] == "login":
            # 登录之后,从响应结果中提取用户id和token
            # (1)获取用户id
            # TestWithdraw.member_id = jsonpath.jsonpath(result, "$..id")[0]  # 通过类名.属性名设置类属性
            member_id = jsonpath.jsonpath(result, "$..id")[0]
            setattr(TestData, "member_id", str(
                member_id))  #使用setattr设置TestData类,member_id属性,属性值为member_id
            # (2)提取token
            token_type = jsonpath.jsonpath(result, "$..token_type")[0]
            token = jsonpath.jsonpath(result, "$..token")[0]
            # TestWithdraw.token_data = token_type + " " + token# 通过类名.属性名设置类属性
            token_data = token_type + " " + token  # 通过类名.属性名设置类属性
            setattr(
                TestData, "token_data",
                token_data)  # 使用setattr设置TestData类,token_data属性,属性值为token_data

            # 设置类属性还可以通过setattr进行设置
            # 下面这行代码和上面那行代码是一个意思,都是将token设为类属性
            setattr(TestWithdraw, "token_data", token_type + " " + token)
            # 第一个参数:类名
            # 第二个参数:属性名
            # 第三个参数:对应的属性值
        # 第三步:比对预期结果和实际结果
        try:
            self.assertEqual(expected["code"], result["code"])
            self.assertEqual(expected["msg"], result["msg"])
            # 提现后,进行数据库校验
            if test_data_cases["check_sql"]:
                sql = test_data_cases["check_sql"].format(
                    conf.get_str("test_data", "user"))
                # 获取提现之后的余额
                end_money = self.db.get_one(sql)[0]
                # 获取请求参数里面的充值金额
                recharge_money = decimal.Decimal(str(data["amount"]))
                my_log.info("提现之前金额为:{}\n,提现金额为:{}\n,提现之后金额为:{}\n".format(
                    start_money, recharge_money, end_money))
                # 进行断言
                self.assertEqual(recharge_money, start_money - end_money)
        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"]))