예제 #1
0
def random_phone():
    mysql = DoMysql()
    while True:
        phone = create_phone()
        sql = f"select * from member where MobilePhone={phone}"
        if not mysql.find_count(sql):
            return phone
예제 #2
0
 def setUp(self):
     self.db = DoMysql()
     # 随机产生身份证号,放入上下文
     ID_card_No = get_card_id()
     setattr(Context, 'cre_id', ID_card_No)
     #实名认证前查询实名认证表记录
     auth_sql = 'SELECT COUNT(*) count FROM user_db.t_user_auth_info;'
     self.before_auth_count = self.db.fetch_one(auth_sql)['count']
예제 #3
0
    def test_001(self,item):
        global result#指明全球变量
        global COOKIES#设置cookies为全局变量
        url=item["url"]
        method=item["method"]
        param=item["param"]
        case_id=item["case_id"]
        modular=item["modular"]
        title=item["title"]
        expected=item["expected"]
        sql=item["sql"]
        print(sql)
        param=get_data.GetData().replace(param)
        print("现在的param是{}".format(param))
        if sql is not None:
         sql=get_data.GetData().replace(sql)
         print("现在的sql是{}".format(sql))

        if sql is not None  and eval(sql)["sql_3"] is not None:
        #投资之前查询数据库用户余额保存下来
            before_amount=DoMysql().do_mysql(eval(sql)["sql_3"],1)[0]
            print("before_sql查询结果是{}".format(before_amount))
        my_log.my_info("正在发起{}模块中的第{}条用例:{}".format(modular,case_id,title))
        my_log.my_info("测试数据是:{}".format(param))
        test_result=DoRequests(url,method,eval(param)).request(cookies=getattr(get_data.GetData,"COOKIES"))
        #获取用户的member_id
        if sql is not None  and eval(sql)["sql_1"] is not None:
            member_id=DoMysql().do_mysql(eval(sql)["sql_1"],1)[0]
            setattr(get_data.GetData,"normal_member_id",str(member_id))
        #获取loan_id
        if sql is not None  and eval(sql)["sql_2"] is not None:
            sql=get_data.GetData().replace(sql)
            loan_id=DoMysql().do_mysql(eval(sql)["sql_2"],1)[0]
            setattr(get_data.GetData,"loan_id",str(loan_id))
        #投资之后,再做一个查询,查询数据库里面用户的余额
        #增加一个判断
        if test_result.cookies:#判断请求cookies是否为空
            setattr(get_data.GetData,"COOKIES",test_result.cookies)
        my_log.my_info("测试结果是:{}".format(test_result.json()))
        my_log.my_info("预期结果是:{}".format(eval(expected)))
        try:
            self.assertEqual(eval(expected),test_result.json())
            #增加一个判断,判断是否投资之后用户余额减少
            if sql is not None  and eval(sql)["sql_3"] is not None:
                after_amount=DoMysql().do_mysql(eval(sql)["sql_3"],1)[0]
                print("after_sql查询结果是{}".format(after_amount))
                invest_amount=eval(param)["amount"]
                expected_amount=before_amount-after_amount
                self.assertEqual(invest_amount,expected_amount)
            result="pass"
            my_log.my_info("测试通过了")
        except AssertionError as e:
            my_log.my_error("测试失败,http请求发生错误")
            result="failed"
            raise e
        finally:
            row=case_id+1
            DoExcel(project_path.case_path,"invest").write_data(row,test_result.text,result)
    def test_withdraw(self, item):
        """
        登录状态下,提现成功
        :return:
        """

        # 判断是否需要校验DB
        if item['check_database'] != None:
            Mylog().info("需要校验DB------{}  ".format(item))
            before_sql_result = DoMysql().do_mysql(
                item['check_database'])  # 获取调用接口前DB数据
            Mylog().info("掉接口前sql获得的数据是{}".format(before_sql_result))
            before_amount = before_sql_result[4]
            before_freeze_amount = before_sql_result[5]

            Mylog().info("提现前amount 是{},提现前freeze_amount 是{},待提现金额为{}".format(
                before_amount, before_freeze_amount,
                eval(item['data'])['amount']))
            Mylog().info("开始调用接口")
            res = HttpRequest().get_request(item['url'],
                                            eval(item['data']))  #返回dict类型
            after_sql_result = DoMysql().do_mysql(item['check_database'])
            Mylog().info("掉接口后sql获得的数据是{}".format(before_sql_result))
            after_amount = after_sql_result[4]
            after_freeze_amount = after_sql_result[5]
            Mylog().info("提现后amount 是{},提现后freeze_amount 是{},待提现金额为{}".format(
                after_amount, after_freeze_amount,
                eval(item['data'])['amount']))

            # 判断数据是否更新正确
            if after_freeze_amount == before_freeze_amount + eval(
                    item['data'])['amount']:
                check_result = '数据库校验通过'
                Mylog().info(check_result)
            else:
                check_result = '数据库未校验通过'
                Mylog().info(check_result)
        else:
            res = HttpRequest().get_request(item['url'], eval(item['data']))
            check_result = None
            print(res, type(res))

        try:
            DoAssert().assert_code(item['expected'], res['code'])
            # assert item['expected']==res.json()['code']
            # self.assertEqual(item['expecxted'],res.json()['code'])
            test_result = 'Pass'
        except Exception as e:
            test_result = 'Fail'
            Mylog().error("执行用例失败{}".format(e))
            raise e
        finally:
            pass
            Mylog().info('获取到的结果是{}'.format(res))
            DoExcel(test_data_path).write_back("gift_dealer_manage",
                                               item['case_id'] + 1, str(res),
                                               check_result, test_result)
예제 #5
0
    def test_http_request(self, case):
        global resp
        global TestResult
        Caseid = case['用例序号']
        Module = case['模块']
        Method = case['请求方式']
        Url = case['接口地址']
        Case_name = case['用例名']
        param = case['参数']
        #传参使用字典格式
        Sql = case['sql']
        Expect_Result = eval(case['预期结果'])
        #字典格式断言预期结果与实际结果
        if case['参数'].find("LOANID") != -1:
            param = case['参数'].replace('LOANID', str(getattr(GetData, 'LOAN')))
        #判断参数内是否含有字段'LOANID',存在该字段则将类属性'LOAN'转换为字符串替换"LOANID"
        if case['用例序号'] == 2:
            sql = eval(case['sql'])['sql']
            befor_amount = (DoMysql().domysql(sql))[0]
        #执行第二条用例前,执行用例内sql语句---获取投资前的账户金额

        TestLog().info("正在执行{}模块,第{}条用例,用例名:{}".format(Module, Caseid,
                                                       Case_name))

        resp = TestRequest().testrequest(Method, Url, eval(param),
                                         getattr(GetData, 'COOKIES'))
        #获取请求结果
        if case['用例序号'] == 1:
            sql_2 = eval(case['sql'])['sql_2']
            loan = DoMysql().domysql(sql_2)
            setattr(GetData, 'LOAN', loan[0])
            # 执行第一条语句时,判断是否存在sql语句,有sql语句则执行,并将结果赋值给类属性'LOAN'
        if case['用例序号'] == 2:
            sql = eval(case['sql'])['sql']
            after_amount = (DoMysql().domysql(sql))[0]
        #执行第二条用例后,执行用例内sql语句---获取投资后的账户金额
        if resp.cookies:
            setattr(GetData, 'COOKIES', resp.cookies)

        try:
            if case['用例序号'] == 2:
                amount = float(befor_amount) - float(after_amount)
                self.assertEqual(float(eval(case['参数'])['amount']), amount)
            self.assertEqual(Expect_Result, resp.json())
            #将请求结果转换为字典格式与预期结果对比
            TestResult = 'PASS'
        except AssertionError as e:
            TestLog().info("断言失败{}".format(e))
            TestResult = 'FAILED'
            raise e
        finally:
            TestLog().info("回写实际结果:{}".format(resp.text))
            DoExcel().data_write('invest', Caseid + 1, 9, resp.text)
            TestLog().info("预期结果::{}".format(Expect_Result))
            TestLog().info("回写测试结论:{}".format(TestResult))
            DoExcel().data_write('invest', Caseid + 1, 10, TestResult)
예제 #6
0
class TestUserAuth(unittest.TestCase):
    def setUp(self):
        self.db = DoMysql()
        # 随机产生身份证号,放入上下文
        ID_card_No = get_card_id()
        setattr(Context, 'cre_id', ID_card_No)
        #实名认证前查询实名认证表记录
        auth_sql = 'SELECT COUNT(*) count FROM user_db.t_user_auth_info;'
        self.before_auth_count = self.db.fetch_one(auth_sql)['count']

    @data(*cases)
    def test_user_auth(self, case):
        my_logger.info('正在执行第{}条用例:{}'.format(case.case_id, case.title))
        my_logger.info('-----------开始检查url地址-------------')
        url = ReadConfig().get('test_api', 'url_pre') + case.url
        my_logger.info('请求url:{}'.format(url))
        data = DoRegex().replace(case.data)
        data = json.loads(data)
        my_logger.info('-----------开始检查参数-------------')
        my_logger.info('请求参数:{}'.format(data))
        res = WebserviceRequest(url).get_result(case.port_name, data)
        time.sleep(60)
        my_logger.info('请求结果:{}'.format(res))
        try:
            self.assertEqual(case.expected, res['retInfo'])
            do_excel.bace_write_by_case_id('verifiedUserAuth', case.case_id,
                                           str(res), 'success')
            Test_result = 'pass'
        except AssertionError as e:
            my_logger.error('出错了,{}'.format(e))
            do_excel.bace_write_by_case_id('verifiedUserAuth', case.case_id,
                                           str(res), 'fail')
            Test_result = 'fail'
            raise e
        except Exception as e:
            raise e

        my_logger.info('本条用例测试结果:{}'.format(Test_result))

        # 如果发送短信验证码成功
        if res['retCode'] == '0' and case.port_name == 'sendMCode':
            sql_code = 'SELECT Fverify_code FROM sms_db_20.t_mvcode_info_3 where Fmobile_no={0};'.format(
                getattr(Context, 'normal_mobile'))
            verify_code = DoMysql().fetch_one(sql_code)['Fverify_code']
            if verify_code:  # 如果查到验证码就放入上下文
                setattr(Context, 'verify_code', verify_code)

        # 如果注册成功,查询uid放入上下文
        if res['retCode'] == '0' and case.port_name == 'userRegister':
            sql_uid = "SELECT Fuid uid FROM user_db.t_user_info where Fuser_id='{0}' and Fip='{1}' ORDER BY Fcreate_time DESC;".format(
                getattr(Context, 'user_id'), Context.client_ip)
            uid = str(DoMysql().fetch_one(sql_uid)['uid'])
            if uid:  # 如果查询到Fuid就放入上下文
                setattr(Context, 'uid', uid)
예제 #7
0
 def test_api(self, item):
     passorfail = None
     #请求之前完成loanid的替换
     if item['data'].find('${loanid}') != -1:
         if getattr(GetData, 'loanid') == None:
             id = DoMysql.cnn_db(
                 'select max(id) from loan where memberid=82')[0]
             item['data'] = str(item['data']).replace('${loanid}', str(id))
             setattr(GetData, 'loanId', id)  #利用反射去存储结果
         else:
             item['data'] = str(item['data']).replace(
                 '${loanid}', str(getattr(GetData, 'LoanId')))
     #判断sql语句
     if item['sql'] == None:  #没有sql语句时
         print('正在执行的用例是:第{}条用例'.format(item['case_id']))
         res = HttpRequest().http_request(item['url'], eval(item['data']),
                                          item['http_method'],
                                          getattr(GetData, 'COOKIE'))
     else:  #有sql语句时
         print('正在执行的用例是:第{}条用例'.format(item['case_id']))
         sql = eval(item['sql'])['sql']
         #http请求前
         before_amount = DoMysql.cnn_db(sql)[0]
         res = HttpRequest().http_request(item['url'], eval(item['data']),
                                          item['http_method'],
                                          getattr(GetData, 'COOKIE'))
         #http请求后
         after_amount = DoMysql.cnn_db(sql)[0]
         amount = abs(after_amount - before_amount)
         if str(amount) == str(eval(item['data'])['amount']):
             check_res = '数据库校验正确'
         else:
             check_res = '数据库校验失败'
         DoExcel.write_checkres(testcase_path, item['interface'],
                                item['case_id'], check_res)
     print(res.json())
     if res.cookies:
         setattr(GetData, 'COOKIE', res.cookies)
     try:
         self.assertEqual(str(item['excepted']),
                          res.json()['code'])  # 断言,没有断言默认不管对错测试用例都执行通过
         passorfail = "成功"
     except Exception as e:
         print('失败用例{},{}:{}'.format(item['interface'], item['case_id'],
                                     res.json()))
         passorfail = "失败"
         raise e
     finally:
         DoExcel.write_back(testcase_path, item['interface'],
                            item['case_id'], str(res.json()), passorfail)
예제 #8
0
    def test_http_request(self, a):
        # print("测试数据是:",a)
        # print("目前正在执行第%s条用例"%a[0])
        logger.info("测试数据是:{0}".format(a))
        logger.info("目前正在执行第%s条用例" % a[0])
        global COOKIES
        # IP+a[4]  ip地址与uri的拼接
        res = HttpRequest(IP + a[4], a[5]).http_request(a[3], cookies=COOKIES)
        if res.cookies != {}:  # 判断长度或者是判断是否为空{}
            COOKIES = res.cookies  # 只有登录才会产生cookies
        # print(res.json())
        # 检查数据库
        # eval(a[6])
        print(a[7]['sql_data'])
        print(type(a[7]['sql_data']))
        sql_result = DoMysql().do_mysql(a[7]['sql'], (str(a[7]['sql_data']), ))
        try:
            self.assertEqual(str(sql_result), a[7]['expected'])
            check_sql_result = 'PASS'
        except AssertionError as e:
            check_sql_result = 'FAIL'
            raise e
        finally:
            self.t.write_data(a[0] + 1, 2, str(sql_result), check_sql_result)

        try:
            self.assertEqual(str(a[6]), res.json()['code'])
            result = 'PASS'
            # self.t.write_data(a[0]+1,str(res.json()),test_result)
        except AssertionError as e:
            result = 'Fail'
            # self.t.write_data(a[0]+1,str(res.json()),test_result)
            raise e  # 跟return一样 中断代码
        finally:  #
            self.t.write_data(a[0] + 1, 1, str(res.json()), result)
예제 #9
0
class TestRegister(unittest.TestCase):
    def setUp(self):
        self.db = DoMysql()
        sql = 'SELECT COUNT(*) count FROM user_db.t_user_info;'
        self.before_line_count = self.db.fetch_one(sql)['count']

    @data(*cases)
    def test_register(self, case):
        my_logger.info('正在执行第{}条用例:{}'.format(case.case_id, case.title))
        my_logger.info('-----------开始检查url地址-------------')
        url = ReadConfig().get('test_api', 'url_pre') + case.url
        my_logger.info('请求url:{}'.format(url))
        # 因注册的用户名不能重复,做随机处理
        last_user_id = random_string.create_str()
        setattr(Context, 'user_id', last_user_id)
        # 因测试验证码超时需要新的手机号验证
        if case.title == '发送短信验证码用于超时':
            normal_mobile = mobile_phone.creat_mobile()
            setattr(Context, 'normal_mobile', normal_mobile)
        data = DoRegex.replace(case.data)
        data = json.loads(data)
        my_logger.info('-----------开始检查参数-------------')
        my_logger.info('注册请求参数:{0}'.format(data))
        if case.title == '注册验证码超时':
            time.sleep(500)
예제 #10
0
    def test_user_auth(self, case):
        my_logger.info('正在执行第{}条用例:{}'.format(case.case_id, case.title))
        my_logger.info('-----------开始检查url地址-------------')
        url = ReadConfig().get('test_api', 'url_pre') + case.url
        my_logger.info('请求url:{}'.format(url))
        data = DoRegex().replace(case.data)
        data = json.loads(data)
        my_logger.info('-----------开始检查参数-------------')
        my_logger.info('请求参数:{}'.format(data))
        res = WebserviceRequest(url).get_result(case.port_name, data)
        time.sleep(60)
        my_logger.info('请求结果:{}'.format(res))
        try:
            self.assertEqual(case.expected, res['retInfo'])
            do_excel.bace_write_by_case_id('verifiedUserAuth', case.case_id,
                                           str(res), 'success')
            Test_result = 'pass'
        except AssertionError as e:
            my_logger.error('出错了,{}'.format(e))
            do_excel.bace_write_by_case_id('verifiedUserAuth', case.case_id,
                                           str(res), 'fail')
            Test_result = 'fail'
            raise e
        except Exception as e:
            raise e

        my_logger.info('本条用例测试结果:{}'.format(Test_result))

        # 如果发送短信验证码成功
        if res['retCode'] == '0' and case.port_name == 'sendMCode':
            sql_code = 'SELECT Fverify_code FROM sms_db_20.t_mvcode_info_3 where Fmobile_no={0};'.format(
                getattr(Context, 'normal_mobile'))
            verify_code = DoMysql().fetch_one(sql_code)['Fverify_code']
            if verify_code:  # 如果查到验证码就放入上下文
                setattr(Context, 'verify_code', verify_code)
예제 #11
0
 def test_001(self, item):
     global result  #指明全球变量
     global COOKIES  #设置cookies为全局变量
     url = item["url"]
     method = item["method"]
     param = item["param"]  #返回的是字符串类型的数据
     case_id = item["case_id"]
     modular = item["modular"]
     title = item["title"]
     expected = item["expected"]
     sql = item["sql"]
     if sql != None:
         sql = get_data.GetData().replace(sql)
         print(sql)
     param = get_data.GetData().replace(param)
     print(param)
     my_log.my_info("正在发起{}模块中的第{}条用例:{}".format(modular, case_id, title))
     my_log.my_info("测试数据是:{}".format(param))
     test_result = DoRequests(
         url, method,
         eval(param)).request(cookies=getattr(get_data.GetData, "COOKIES"))
     #增加一个判断是否查询数据库
     if sql != None:  #如果测试用例中的query不为none就进行数据库查询操作
         sql_data = DoMysql().do_mysql(eval(sql)["sql"], 1)
         member_id = sql_data[0]
         setattr(get_data.GetData, "normal_member_id", str(member_id))
         print(getattr(get_data.GetData, "normal_member_id"))
     #增加一个判断 是在完成完请求之后才去判断
     if test_result.cookies:  #判断请求cookies是否为空
         setattr(get_data.GetData, "COOKIES", test_result.cookies)
     my_log.my_info("测试结果是:{}".format(test_result.json()))
     my_log.my_info("预期结果是:{}".format(eval(expected)))
     # expected=eval(expected)
     # test_result=test_result.json()
     # # if case_id==2:
     #     expected["data"]=test_result["data"]
     try:
         self.assertEqual(
             eval(expected)["status"],
             test_result.json()["status"])
         self.assertEqual(
             eval(expected)["code"],
             test_result.json()["code"])
         self.assertEqual(eval(expected)["msg"], test_result.json()["msg"])
         result = "pass"
         my_log.my_info("测试通过了")
     except AssertionError as e:
         my_log.my_error("测试失败,http请求发生错误")
         result = "failed"
         raise e
     finally:
         row = case_id + 1
         DoExcel(project_path.case_path,
                 "get_InvestsByMemberId").write_data(
                     row, test_result.text, result)
예제 #12
0
    def test_cases(self, case):
        global TestResult  # 全局变量
        # global COOKIES#声明是一个全局变量
        method = case['Method']
        url = case['Url']
        param = eval(case['Params'])

        # 发起测试
        my_log.info('-------正在测试{}模块里面第{}条测试用例:{}'.format(case['Module'], case['CaseId'], case['Title']))
        my_log.info('测试数据是:{}'.format(case))
        # 投资前查询数据库获取余额,保存
        if case['sql'] is not None:
            sql = eval(case['sql'])['sql']
            before_amount = DoMysql().do_mysql(sql)[0]

        resp = HttpRequest().http_request(method, url, param, cookies=getattr(GetData, 'COOKIE'))  # 传参
        # 实实在在的http请求发生之后才去加一个判断,判断是否产生了cookies
        if resp.cookies:  # 判断请求的cookies是否为空 不为空其实就是True
            setattr(GetData, 'COOKIE', resp.cookies)  # 我们可以更新COOKIES这个全局变量的值

        try:
            self.assertEqual(eval(case['ExpectedResult']), resp.json())
            # 再加一个断言 与的关系
            # 投资后的查询数据库的余额
            if case['sql'] is not None:
                sql = eval(case['sql'])['sql']
                after_amount = DoMysql().do_mysql(sql)[0]

                invest_amount = param['amount']  # 投资金额
                expect_amount = before_amount - invest_amount
                self.assertEqual(expect_amount, after_amount)

            TestResult = 'Pass'  # 请注意这里
        except Exception as e:
            TestResult = 'Failed'
            my_log.error('http请求测试用例出错了,错误是:{}'.format(e))
            raise e  # 处理完异常之后  不要留在家里 要抛出去! raise e
        finally:
            self.t.write_back(case['CaseId'] + 1, 9, resp.text)  # 请注意这里
            self.t.write_back(case['CaseId'] + 1, 10, TestResult)

        my_log.info('实际结果:{}'.format(resp.json()))  # http发送请求拿到的实际返回值
예제 #13
0
    def test_001(self, item):
        global result  #指明全球变量
        global COOKIES  #设置cookies为全局变量
        url = item["url"]
        method = item["method"]
        param = item["param"]
        case_id = item["case_id"]
        modular = item["modular"]
        title = item["title"]
        expected = item["expected"]
        sql = item["sql"]
        print(sql)
        param = get_data.GetData().replace(param)
        print("现在的param是{}".format(param))
        if sql is not None:
            sql = get_data.GetData().replace(sql)
            print(type(sql))
            print("现在的sql是{}".format(sql))

        my_log.my_info("正在发起{}模块中的第{}条用例:{}".format(modular, case_id, title))
        my_log.my_info("测试数据是:{}".format(param))
        test_result = DoRequests(
            url, method,
            eval(param)).request(cookies=getattr(get_data.GetData, "COOKIES"))
        #获取loan_id
        if sql is not None and eval(sql)["sql"] is not None:
            print("测试的sql{}".format(eval(sql)["sql"]))
            sql = get_data.GetData().replace(sql)
            loan_id = DoMysql().do_mysql(eval(sql)["sql"], 1)[0]
            setattr(get_data.GetData, "loan_id", str(loan_id))
        #增加一个判断
        if test_result.cookies:  #判断请求cookies是否为空
            setattr(get_data.GetData, "COOKIES", test_result.cookies)
        my_log.my_info("测试结果是:{}".format(test_result.json()))
        my_log.my_info("预期结果是:{}".format(eval(expected)))
        try:
            self.assertEqual(
                eval(expected)["status"],
                test_result.json()["status"])
            self.assertEqual(
                eval(expected)["code"],
                test_result.json()["code"])
            self.assertEqual(eval(expected)["msg"], test_result.json()["msg"])
            result = "pass"
            my_log.my_info("测试通过了")
        except AssertionError as e:
            my_log.my_error("测试失败,http请求发生错误")
            result = "failed"
            raise e
        finally:
            row = case_id + 1
            DoExcel(project_path.case_path,
                    "get_InvestsByLoanId").write_data(row, test_result.text,
                                                      result)
예제 #14
0
 def test_001(self, item):
     global result  # 指明全局变量
     global COOKIES  # 设置cookies为全局变量
     global before_amount
     url = item["url"]
     method = item["method"]
     param = item["param"]
     case_id = item["case_id"]
     modular = item["modular"]
     title = item["title"]
     expected = item["expected"]
     sql = item["sql"]
     param = get_data.GetData().replace(param)
     print("目前的param是{}".format(param))
     if sql is not None:
         sql = get_data.GetData().replace(sql)
         print("目前的sql是{}".format(sql))
         before_amount = DoMysql().do_mysql(eval(sql)["sql"])[0]
         my_log.my_info("充值之前账户余额:{}".format(before_amount))
     my_log.my_info("正在发起{}模块中的第{}条用例:{}".format(modular, case_id, title))
     my_log.my_info("测试数据是:{}".format(param))
     test_result = DoRequests(
         url, method,
         eval(param)).request(cookies=getattr(get_data.GetData, "COOKIES"))
     # 增加一个判断
     if test_result.cookies:  # 判断请求cookies是否为空
         setattr(get_data.GetData, "COOKIES", test_result.cookies)
     my_log.my_info("测试结果是:{}".format(test_result.text))
     my_log.my_info("预期结果是:{}".format(eval(expected)))
     try:
         self.assertEqual(
             eval(expected)["code"],
             test_result.json()["total"])
         #     if sql is not None:
         #         after_amount = DoMysql().do_mysql(eval(sql)["sql"], 1)[0]
         #         recharge_amount = int(eval(param)["amount"])
         #         my_log.my_info("充值的金额是:{}".format(str(recharge_amount)))
         #         expected_amount = recharge_amount + before_amount
         #         my_log.my_info("充值之后的用户余额:{}".format(expected_amount))
         #         self.assertEqual(expected_amount, after_amount)
         #         expected = expected.replace("expectedamount", str(expected_amount))
         #     self.assertEqual(eval(expected)["status"], test_result.json()["status"])
         #     self.assertEqual(eval(expected)["code"], test_result.json()["code"])
         #     self.assertEqual(eval(expected)["msg"], test_result.json()["msg"])
         result = "pass"
         my_log.my_info("测试通过了")
     except AssertionError as e:
         my_log.my_error("测试失败,http请求发生错误")
         result = "failed"
         raise e
     finally:
         row = case_id + 1
         DoExcel(project_path.case_path,
                 "invest").write_data(row, test_result.text, result)
예제 #15
0
    def test_login(self, data_item):
        global TOKEN
        print('正在进行第{0}条用例:{1}'.format(data_item['id'],
                                       data_item['description']))
        self.logger.info('正在进行第{0}条用例:{1}'.format(data_item['id'],
                                                  data_item['description']))
        params = eval(data_item['param'])

        if data_item['module'] == '登录':
            if params['mobilecaptcha'] == 'code':
                #去数据库查询验证码替换
                for i in [2]:

                    sql = 'SELECT idstring FROM `pre_captcha_mobile` WHERE mobile={0} ORDER BY captchaid DESC LIMIT 1'.format(
                        params['phone'])
                    code = DoMysql().do_mysql(sql)
                params['mobilecaptcha'] = code[0][0]
        else:
            params['access_token'] = TOKEN

        print('测试数据为{0}'.format(params))
        self.logger.info('测试数据为{0}'.format(params))

        res = HttpRequtser().http_request(data_item['url'],
                                          params,
                                          data_item['HttpMethod'],
                                          verify=False,
                                          headers=header)
        print('测试结果是{0}'.format(res.json()))
        self.logger.info('测试结果是{0}'.format(res.json()))
        if data_item['module'] == '登录':
            if res.json(
            )['data']['access_token']:  # 任何非空数据的布尔值都为True  cookies是一个类字典的格式
                TOKEN = res.json()['data'][
                    'access_token']  # 如果cookies不为空 就替换全局变量的COOKIES 修改全局变量
        try:
            self.assertEqual(str(data_item['ExpectedResult']),
                             str(res.json()['error_code']))
            self.assertEqual(res.status_code, 200)
            print('用例通过')
            self.logger.info('用例通过')
            TestResult = 'PASS'
            Comment = None
        except AssertionError as e:
            print('用例失败错误是{}'.format(e))
            self.logger.error('用例失败错误是{}'.format(e))
            TestResult = 'Failed'
            Comment = res.json()['error_message']
            raise e
        finally:
            DoExce(project_path.test_case_path).write_back(
                'login', data_item['id'] + 1,
                res.json()['error_code'], TestResult, Comment)
예제 #16
0
 def post_sql(self, sql_param):
     '''
     SQL后置处理,有更改、删除和新增操作,暂时不支持查询和参数提取操作
     :param sql_param: 单元格里的参数
     :return: 暂无返回
     '''
     self.logger.info('——进入SQL后置处理——')
     if isinstance(sql_param, dict):
         sql_param = [sql_param]
     for sub_sql in sql_param:
         sql = sub_sql['sql']
         db = sub_sql.get('db') if sub_sql.get('db') else 1
         DoMysql(self.logger).commit_mysql(sql, db=db)
     self.logger.info('——SQL后置处理完成——')
예제 #17
0
    def test_http_request(self, case):
        global resp
        global TestResult
        Caseid = case['用例序号']
        Module = case['模块']
        Method = case['请求方式']
        Url = case['接口地址']
        Case_name = case['用例名']
        param = (case['参数'])
        #传参使用字典格式
        Sql = case['sql']
        Expect_Result = eval(case['预期结果'])
        #字典格式断言预期结果与实际结果

        if case['参数'].find('loanid') != -1:
            param = case['参数'].replace('loanid', str(getattr(GetData, 'RES')))
        #判断参数内是否含有字段'loanid',有的话就把‘loanid字段替换为类属性'RES'的值’
        TestLog().info("正在执行{}模块,第{}条用例,用例名:{}".format(Module, Caseid,
                                                       Case_name))

        resp = TestRequest().testrequest(Method, Url, eval(param),
                                         getattr(GetData, 'COOKIES'))
        #实际结果
        if case['sql']:
            res = (DoMysql().domysql(eval(Sql)['sql']))[0]
            setattr(GetData, 'RES', res)
        #判断sql是否为空,不为空则执行sql,获取到sql执行结果,并赋值给雷属性‘RES’
        if resp.cookies:
            setattr(GetData, 'COOKIES', resp.cookies)

        try:
            self.assertEqual(eval(case['预期结果']), resp.json())
            #将请求结果转换为字典格式与预期结果对比
            TestResult = 'PASS'
        except AssertionError as e:
            TestLog().info("断言失败{}".format(e))
            TestResult = 'FAILED'
            raise e
        finally:
            TestLog().info("回写实际结果:{}".format(resp.text))
            DoExcel().data_write('add_loan', Caseid + 1, 9, resp.text)
            TestLog().info("预期结果::{}".format(Expect_Result))
            TestLog().info("回写测试结论:{}".format(TestResult))
            DoExcel().data_write('add_loan', Caseid + 1, 10, TestResult)
 def setUpClass(cls):
     logger.info('前置操作,连接数据库')
     cls.mysql = DoMysql()
     warnings.simplefilter('ignore', ResourceWarning)
예제 #19
0
        my_logger.info('本条用例测试结果:{}'.format(Test_result))

        # 如果发送短信验证码成功
        if res['retCode'] == '0' and case.port_name == 'sendMCode':
            sql_code = 'SELECT Fverify_code FROM sms_db_20.t_mvcode_info_3 where Fmobile_no={0};'.format(
                getattr(Context, 'normal_mobile'))
            verify_code = DoMysql().fetch_one(sql_code)['Fverify_code']
            if verify_code:  # 如果查到验证码就放入上下文
                setattr(Context, 'verify_code', verify_code)

        # 如果注册成功,查询uid放入上下文
        if res['retCode'] == '0' and case.port_name == 'userRegister':
            sql_uid = "SELECT Fuid uid FROM user_db.t_user_info where Fuser_id='{0}' and Fip='{1}' ORDER BY Fcreate_time DESC;".format(
                getattr(Context, 'user_id'), Context.client_ip)
            uid = str(DoMysql().fetch_one(sql_uid)['uid'])
            if uid:  # 如果查询到Fuid就放入上下文
                setattr(Context, 'uid', uid)

        # 实名认证成功后,数据验证,验证数据库影响行数是否为1
        if res['retCode'] == '0' and case.port_name == 'verifyUserAuth':
            expected = self.before_auth_count + 1  # 预期结果=实名认证前记录数 + 1
            auth_sql = 'SELECT COUNT(*) count FROM user_db.t_user_auth_info;'  # 实名认证成功后再次查询记录数
            actual = DoMysql().fetch_one(auth_sql)['count']
            self.assertEqual(expected, actual)
            my_logger.info('实名认证成功后,查询影响实名认证表行数等于1')

    def tearDown(self):
        self.db.close()
        my_logger.info('关闭数据库连接,测试环境还原')
예제 #20
0
 def setUpClass(cls):
     cls.service = WebService()
     cls.mysql = DoMysql()
     cls.mylog.info('开始执行用例')
예제 #21
0
    def test_001(self, item):
        global result  #指明全球变量
        global COOKIES  #设置cookies为全局变量
        global before_amount
        global withdraw_amount
        url = item["url"]
        method = item["method"]
        param = item["param"]
        case_id = item["case_id"]
        modular = item["modular"]
        title = item["title"]
        expected = item["expected"]
        sql = item["sql"]

        #参数化测试数据
        param = get_data.GetData().replace(param)
        my_log.my_info("目前的param是{}".format(param))

        #判断是否需要执行sql 如果需要执行则运行代码
        if sql is not None:
            sql = get_data.GetData().replace(sql)
            print("目前的sql是{}".format(sql))
            before_amount = DoMysql().do_mysql(eval(sql)["sql"])[0]
            my_log.my_info("体现之前的用户余额是:{}".format(before_amount))

        my_log.my_info("正在发起{}模块中的第{}条用例:{}".format(modular, case_id, title))

        #传入参数 进行接口测试
        test_result = DoRequests(
            url, method,
            eval(param)).request(cookies=getattr(get_data.GetData, "COOKIES"))
        # print(test_result)

        #打印测试结果与实际结果
        # my_log.my_info("目前的测试结果是{}".format(test_result.json()))
        # my_log.my_info("预期结果是:{}".format(eval(expected)))

        #增加一个判断 传递cookies
        if test_result.cookies:  #判断请求cookies是否为空
            setattr(get_data.GetData, "COOKIES", test_result.cookies)

        #打印出测试结果与预期结果
        my_log.my_info("测试结果是:{}".format(test_result.json()))
        my_log.my_info("预期结果是:{}".format(eval(expected)))

        #测试结果与预期结果进行断言
        try:
            if sql is not None:
                after_amount = DoMysql().do_mysql(eval(sql)["sql"], 1)[0]
                my_log.my_info("提现之后的用户余额是:{}".format(after_amount))
                withdraw_amount = int(eval(param)["amount"])
                my_log.my_info("提现金额是:{}".format(str(withdraw_amount)))
                expected_amount = before_amount - withdraw_amount
                self.assertEqual(expected_amount, after_amount)
                expected = expected.replace("expectedamount",
                                            str(expected_amount))
                my_log.my_info("预期的用户余额是:{}".format(expected_amount))
            self.assertEqual(
                eval(expected)["status"],
                test_result.json()["status"])
            self.assertEqual(
                eval(expected)["code"],
                test_result.json()["code"])
            self.assertEqual(eval(expected)["msg"], test_result.json()["msg"])
            result = "pass"
            my_log.my_info("测试通过了")
        except AssertionError as e:
            my_log.my_error("测试失败,http请求发生错误")
            result = "failed"
            raise e
        finally:
            #写回测试结果
            row = case_id + 1
            DoExcel(project_path.case_path,
                    "withdraw").write_data(row, test_result.text, result)
예제 #22
0
        except AssertionError as e:
            my_logger.error('出错了,{}'.format(e))
            do_excel.bace_write_by_case_id('register', case.case_id, str(res),
                                           'fail')
            Test_result = 'fail'
            raise e
        except Exception as e:
            raise e

        my_logger.info('本条用例测试结果:{}'.format(Test_result))

        if case.title == '成功发送短信验证码':  # 如果发送短信验证码成功请求成功,查询验证码
            sql_code = 'SELECT Fverify_code FROM sms_db_20.t_mvcode_info_3 where Fmobile_no={0};'.format(
                getattr(Context, 'normal_mobile'))
            verify_code = DoMysql().fetch_one(sql_code)['Fverify_code']
            if verify_code:  # 如果查到验证码就放入上下文
                setattr(Context, 'verify_code', verify_code)
            else:  # 如果为空,上下文中验证码为空
                setattr(Context, 'verify_code', None)

        # 注册成功数据验证
        if res['retCode'] == '0' and case.port_name == 'userRegister':

            # 验证如果注册成功,影响数据库的行数是否等于1
            expected = self.before_line_count + 1  # 期望结果=请求前行数 + 1
            # print('期望结果:', expected)
            sql2 = 'SELECT COUNT(*) count FROM user_db.t_user_info;'
            actual = DoMysql().fetch_one(sql2)['count']  # 实际结果=请求注册后行数
            # print('实际结果:', actual)
            self.assertEqual(expected, actual)
예제 #23
0
 def setUp(self):
     self.db = DoMysql()
     sql = 'SELECT COUNT(*) count FROM user_db.t_user_info;'
     self.before_line_count = self.db.fetch_one(sql)['count']
예제 #24
0
 def setUpClass(cls):
     cls.url = config.get("api", "url")
     cls.request = HttpRequest()
     cls.mysql = DoMysql()
예제 #25
0
 def setUpClass(cls):
     print("begin")
     cls.request = HttpRequest()
     cls.mysql = DoMysql()
예제 #26
0
 def setUpClass(cls):
     cls.http = HttpSession()
     cls.mysql = DoMysql()
예제 #27
0
    def test_http_request(self, case):
        # global COOKIES
        #声明COOKIES为全局变量
        global resp
        global TestResult
        # global before_amount
        # global after_amount
        Caseid = case['用例序号']
        Module = case['模块']
        Method = case['请求方式']
        Url = case['接口地址']
        Case_name = case['用例名']
        param = eval(case['参数'])
        #传参使用字典格式
        Sql = case['sql']
        Expect_Result = case['预期结果']
        #字典格式断言预期结果与实际结果

        if case['sql'] is not None:
            before_amount = (DoMysql().domysql(eval(case['sql'])['sql']))[0]
        #充值前账户金额

        TestLog().info("正在执行{}模块,第{}条用例,用例名:{}".format(Module, Caseid,
                                                       Case_name))
        getattr(GetData, 'COOKIES')

        resp = TestRequest().testrequest(Method,
                                         Url,
                                         param,
                                         cookies=getattr(GetData, 'COOKIES'))
        #获取请求结果  getattr(GetData,'COOKIES') --反射,获取类属性的值
        if case['sql'] is not None:
            after_amount = (DoMysql().domysql(eval(case['sql'])['sql']))[0]
            setattr(GetData, 'leaveamout', after_amount)
        if Expect_Result.find('money') != -1:
            Expect_Result = case['预期结果'].replace(
                'money', str(getattr(GetData, 'leaveamout')))

        #充值后账户金额
        if resp.cookies:
            #判断请求结果cookies是否为真
            setattr(GetData, 'COOKIES', resp.cookies)
            #反射,将登陆产生的cookie赋值给变量COOKIES

        try:
            if case['sql'] is not None:
                #sql不为空的情况下再判断
                Expect_amount = float(before_amount) + float(param['amount'])
                #预期金额=原金额+充值金额
                self.assertEqual(after_amount, Expect_amount)
                #断言实际金额与预期金额
            self.assertEqual(eval(Expect_Result), resp.json())
            #将请求结果转换为字典格式与预期结果对比
            TestResult = 'PASS'
        except AssertionError as e:
            TestLog().info("断言失败{}".format(e))
            TestResult = 'FAILED'
            raise e
        finally:
            TestLog().info("回写实际结果:{}".format(resp.text))
            DoExcel().data_write('recharge', Caseid + 1, 9, resp.text)
            TestLog().info("预期结果::{}".format(Expect_Result))
            TestLog().info("回写测试结论:{}".format(TestResult))
            DoExcel().data_write('recharge', Caseid + 1, 10, TestResult)
예제 #28
0
 def setUpClass(cls):
     cls.request = HttpRequest()
     cls.mysql = DoMysql()
예제 #29
0
    def test_http_request(self, a):
        logger.info("测试数据是:{0}".format(a))  #!!!括号中不能用逗号的方式传递变量值
        logger.info("目前正在执行第%s条用例" % a['case_id'])

        global COOKIES

        logger.info("请求的地址为:%s" % (ip + a['url']))
        logger.info("请求的参数为:%s" % a['params'])
        # print('a5的类型',type(a[5]))

        #此方法是针对list形式
        # res=HttpRequest(ip+a[4],(a[5])).httpRequest(a[3],cookies=COOKIES)
        #此方法是针对字典取值,可以根据key取value值
        res = HttpRequest(ip + a['url'],
                          eval(a['params'])).httpRequest(a['method'],
                                                         cookies=COOKIES)

        if res.cookies != {}:  #判断cookies是否为空用{},或用len(res.cookies)==0
            COOKIES = res.cookies
        # print(res.json())

        #检查数据库的值
        # sql_result=DoMysql().do_mysql(a[7]['sql'],(str(a[7]['sql_data']),))

        #判断是否对数据库进行检查
        if a['check_sql'] != None:  #是否需要对数据库进行检查
            sql_result = DoMysql().do_mysql(eval(a['check_sql'])['sql'])
            try:
                self.assertEqual(
                    eval(a['check_sql'])['expected'], str(sql_result)
                )  #!!!a['check_sql]['expected'] 这种用法错误,应将前面转换成字典类型
                check_sql_result = 'PASS'
            except AssertionError as e:
                check_sql_result = 'FAIL'
                raise e
            finally:
                self.t.write_data(
                    int(a['case_id']) + 1, 2, str(sql_result),
                    check_sql_result)

        #判断是否存在id和regtime需要替换
        if a['expect_result'].find("${id}") != -1 and a['expect_result'].find(
                '${regtime}') != -1:
            #获取手机号 从params里面去获取手机号
            mobilephone = eval(a['params'])['mobilephone']  #!!! 记住,字典的键值要用“”
            #替换id
            member_id = DoMysql().do_mysql(
                'select id from member where mobilephone=%s' %
                mobilephone)[0]  #sql返回是元组类型
            #替换regtime
            regtime = DoMysql().do_mysql(
                'select regtime from member where mobilephone=' +
                mobilephone)[0]

            expected_result = eval(a['expect_result'])
            expected_result['data']['id'] = member_id
            expected_result['data']['regtime'] = str(regtime) + '.0'
        else:
            expected_result = eval(a['expect_result'])

        #检查excel中的预期值
        try:
            self.assertEqual(expected_result, res.json())  #!!!预期结果要转换成str
            result = 'PASS'
        except AssertionError as e:
            logger.error("断言报错信息是%s" % e)
            result = 'FAIL'
            raise e  #!!!终止后面的代码
        finally:
            self.t.write_data(
                int(a['case_id']) + 1, 1, str(res.json()), result)
예제 #30
0
 def setUpClass(cls):
     cls.mysql = DoMysql()
     warnings.simplefilter("ignore", ResourceWarning)