Пример #1
0
    def test_register(self, item):
        # 第一步:准备用例数据
        # 1)接口地址
        url = self.base_url + item["url"]
        # 2)接口请求参数
        params = eval(item["data"])
        # 3)获取请求方法
        method = item["method"].lower()
        # 4)用例预期结果
        expected = eval(item["expected"])

        # 第二步:请求接口,获取返回实际参数
        response = requests.request(method, url, json=params)
        res = response.json()
        # 第三步:断言
        try:
            # self.assertEqual(expected['code'], res['code'])
            self.assertDictIn(expected, res)
        except AssertionError as e:
            # 记录日志
            my_log.error("用例--【{}】---执行失败".format(item['title']))
            my_log.exception(e)
            raise e
        else:
            my_log.info("用例--【{}】---执行通过".format(item['title']))
 def test_nb_grant_column_list(self,item):
     #第一步:准备用例数据
     #1)获取请求接口地址
     url=self.base_url+item["url"]
     #2)请求接口参数
     #替换参数IMEI
     if '#IMEI#' in item['data']:
         imei = self.IMEI
         item['data'] = item['data'].replace('#IMEI#',imei)
     parms=eval(item["data"])
     #3)请求头
     #类级别前置以获取
     #4)获取请求方法
     method=item["method"].lower()
     #5)用例预期结果
     expected=eval(item["expected"])
     #第二步:请求接口,获取返回实际参数
     response=requests.request(method,url=url,json=parms,headers=self.token)
     res=response.json()
     #第三部:断言
     try:
         self.assertDictIn(expected, res)
         # 成员断言,因为返回的字段不确定性,提取关键字段
     except AssertionError as e:
         # 记录日志
         my_log.error("用例--【{}】---执行失败".format(item['title']))
         my_log.exception(e)
         raise e
     else:
         my_log.info("用例--【{}】---执行通过".format(item['title']))
    def test_nb_new_password(self, item):
        #门锁类型获取
        lock_type = item["lock_type"]
        if lock_type <= self.practical_lock_type:
            #第一步:准备用例数据
            #1)获取请求接口地址
            url = self.base_url + item["url"]
            #2)请求接口参数
            #替换参数IMEI
            if '#IMEI#' in item['data']:
                imei = self.IMEI
                item['data'] = item['data'].replace('#IMEI#', imei)
            #替换参数开始和结束时间
            if "#start_time#" in item["data"]:
                start_time = self.start_time
                item["data"] = item["data"].replace("#start_time#", start_time)

            if "#end_time#" in item["data"]:
                end_time = self.end_time
                item["data"] = item["data"].replace("#end_time#", end_time)
            parms = eval(item["data"])
            #3)请求头
            #类级别前置以获取
            #4)获取请求方法
            method = item["method"].lower()
            #5)用例预期结果
            expected = eval(item["expected"])
            #第二步:请求接口,获取返回实际参数
            response = requests.request(method,
                                        url=url,
                                        json=parms,
                                        headers=self.token)
            res = response.json()
            #第三部:断言
            try:
                self.assertDictIn(expected, res)
                # 成员断言,因为返回的字段不确定性,提取关键字段
            except AssertionError as e:
                # 记录日志
                my_log.error("用例--【{}】---执行失败".format(item['title']))
                # my_log.error(e)
                # 输出日志用这个方法,输出的日志比较详细点
                my_log.exception(e)
                raise e
            else:
                my_log.info("用例--【{}】---执行通过".format(item['title']))
                # 通过门锁类型,来预期录入所耗时间
                if item["lock_type"] == 3:
                    print("请激活门锁,录入开锁信息,45s")
                    time.sleep(45)
                    print("等待结束")
                if item["lock_type"] == 1:
                    print("请激活门锁,录入开锁信息,30s")
                    time.sleep(22)
                    print("等待结束")

        else:
            my_log.info("用例--【{}】---无需执行".format(item['title']))
    def test_lk_remove_the_door(self,item):
        #门锁类型获取
        lock_type=item["lock_type"]
        if lock_type<=self.practical_lock_type:
            #第一步:准备用例数据
            #1)获取请求接口地址
            url=self.base_url+item["url"]
            #2)请求接口参数
            #替换参数IMEI
            if '#IMEI#' in item['data']:
                imei = self.IMEI
                item['data'] = item['data'].replace('#IMEI#',imei)
            #替换参数开始和结束时间
            if "#start_time#" in item["data"]:
                start_time=self.start_time
                item["data"] = item["data"].replace("#start_time#",start_time)

            if "#end_time#" in item["data"]:
                end_time=self.end_time
                item["data"] = item["data"].replace("#end_time#",end_time)
            parms=eval(item["data"])
            #3)请求头
            #类级别前置以获取
            #4)获取请求方法
            method=item["method"].lower()
            #5)用例预期结果
            expected=eval(item["expected"])
            #第二步:请求接口,获取返回实际参数
            response=requests.request(method,url=url,json=parms,headers=self.token)
            res=response.json()
            #第三部:断言
            try:
                # 断言code和msg字段是否一致
                # self.assertEqual(expected['code'], res['code'])
                # self.assertEqual(expected['msg'], res['msg'])
                self.assertDictIn(expected, res)
                # 成员断言,因为返回的字段不确定性,提取关键字段
            except AssertionError as e:
                # 记录日志
                my_log.error("用例--【{}】---执行失败".format(item['title']))
                # my_log.error(e)
                # 输出日志用这个方法,输出的日志比较详细点
                my_log.exception(e)
                # 回写结果到excel(根据公司中实际需求来决定用例结果写不写到excel中) # 注:回写excel需要花费大量的时间
                raise e
            else:
                my_log.info("用例--【{}】---执行通过".format(item['title']))
        else:
            my_log.info("用例--【{}】---无需执行".format(item['title']))
Пример #5
0
 def test_nb_new_password(self,item):
     #第一步:准备用例数据
     #1)获取请求接口地址
     url=self.base_url+item["url"]
     #2)请求接口参数
     #替换参数IMEI
     if '#IMEI#' in item['data']:
         imei = self.IMEI
         item['data'] = item['data'].replace('#IMEI#',imei)
     parms=eval(item["data"])
     #3)请求头
     #类级别前置以获取
     #4)获取请求方法
     method=item["method"].lower()
     #5)用例预期结果
     expected=eval(item["expected"])
     #第二步:请求接口,获取返回实际参数
     response=requests.request(method,url=url,json=parms,headers=self.token)
     res=response.json()
     # print("预期结果{}".format(item["expected"]))
     # print("返回结果{}".format(res))
     #第三部:断言
     try:
         # 断言code和msg字段是否一致
         # self.assertEqual(expected['code'], res['code'])
         # self.assertEqual(expected['msg'], res['msg'])
         self.assertDictIn(expected, res)
         # 成员断言,因为返回的字段不确定性,提取关键字段
     except AssertionError as e:
         # 记录日志
         my_log.error("用例--【{}】---执行失败".format(item['title']))
         # my_log.error(e)
         # 输出日志用这个方法,输出的日志比较详细点
         my_log.exception(e)
         # 回写结果到excel(根据公司中实际需求来决定用例结果写不写到excel中) # 注:回写excel需要花费大量的时间
         raise e
     else:
         my_log.info("用例--【{}】---执行通过".format(item['title']))
    def test_nb_delete_the_authorized(self, item):

        #第一步:准备用例数据
        #1)获取请求接口地址
        url = self.base_url + item["url"]
        #2)请求接口参数
        #替换参数IMEI
        if '#IMEI#' in item['data']:
            imei = self.IMEI
            item['data'] = item['data'].replace('#IMEI#', imei)
        #替换参数开始和结束时间
        if "#start_time#" in item["data"]:
            start_time = self.start_time
            item["data"] = item["data"].replace("#start_time#", start_time)
        if "#end_time#" in item["data"]:
            end_time = self.end_time
            item["data"] = item["data"].replace("#end_time#", end_time)
        #替换修改密码需要的ID
        if "#userId#" in item["data"]:
            userId = self.userId
            item["data"] = item["data"].replace("#userId#", userId)
        if "#usePwId#" in item["data"]:
            usePwId = self.usePwId
            item["data"] = item["data"].replace("#usePwId#", usePwId)
        parms = eval(item["data"])
        print("请求参数", parms)
        #3)请求头
        #类级别前置以获取
        #4)获取请求方法
        method = item["method"].lower()
        #5)用例预期结果
        expected = eval(item["expected"])
        #第二步:请求接口,获取返回实际参数
        response = requests.request(method,
                                    url=url,
                                    json=parms,
                                    headers=self.token)
        res = response.json()
        print("返回数据", res)
        if item["url"] == "/userAuthorize/add":
            TestNBdeleteTheAuthorized.userId = jsonpath(res, "$..userId")[0]
            TestNBdeleteTheAuthorized.usePwId = jsonpath(res, "$..usePwId")[0]
        #第三部:断言
        try:
            self.assertDictIn(expected, res)
            # 成员断言,因为返回的字段不确定性,提取关键字段
        except AssertionError as e:
            # 记录日志
            my_log.error("用例--【{}】---执行失败".format(item['title']))
            # my_log.error(e)
            # 输出日志用这个方法,输出的日志比较详细点
            my_log.exception(e)
            raise e
        else:
            my_log.info("用例--【{}】---执行通过".format(item['title']))
            # 通过门锁类型,来预期录入所耗时间
            if item["lock_type"] == 3:
                print("请激活门锁,录入开锁信息,45s")
                time.sleep(45)
                print("等待结束")
            if item["lock_type"] == 1 or item["lock_type"] == 2:
                print("请激活门锁,录入开锁信息,40s")
                time.sleep(40)
                print("等待结束")
 def test_nb_modify_authorization_time(self, item):
     #门锁类型获取
     lock_type = item["lock_type"]
     if lock_type <= self.practical_lock_type:
         #第一步:准备用例数据
         #1)获取请求接口地址
         url = self.base_url + item["url"]
         #2)请求接口参数
         #替换参数IMEI
         if '#IMEI#' in item['data']:
             imei = self.IMEI
             item['data'] = item['data'].replace('#IMEI#', imei)
         #替换参数开始和结束时间
         if "#start_time#" in item["data"]:
             start_time = self.start_time
             item["data"] = item["data"].replace("#start_time#", start_time)
         if "#end_time#" in item["data"]:
             end_time = self.end_time
             item["data"] = item["data"].replace("#end_time#", end_time)
         if "#userId#" in item["data"]:
             userId = self.userId
             item["data"] = item["data"].replace("#userId#", userId)
         if "#start_time_after_modification#" in item["data"]:
             start_time_after_modification = self.start_time_after_modification
             item["data"] = item["data"].replace(
                 "#start_time_after_modification#",
                 start_time_after_modification)
         if "#end_time_after_modification#" in item["data"]:
             end_time_after_modification = self.end_time_after_modification
             item["data"] = item["data"].replace(
                 "#end_time_after_modification#",
                 end_time_after_modification)
         parms = eval(item["data"])
         print("__________________________________", parms)
         #3)请求头
         #类级别前置以获取
         #4)获取请求方法
         method = item["method"].lower()
         #5)用例预期结果
         expected = eval(item["expected"])
         #第二步:请求接口,获取返回实际参数
         response = requests.request(method,
                                     url=url,
                                     json=parms,
                                     headers=self.token)
         res = response.json()
         #提取返回出来的参数
         if item["title"] == "NB授权-普通用户新增-密码":
             TestNBmodityAuthorizationTime.userId = jsonpath(
                 res, "$..userId")[0]
             TestNBmodityAuthorizationTime.usePwId = jsonpath(
                 res, "$..usePwId")[0]
         #第三部:断言
         try:
             self.assertDictIn(expected, res)
             # 成员断言,因为返回的字段不确定性,提取关键字段
         except AssertionError as e:
             # 记录日志
             my_log.error("用例--【{}】---执行失败".format(item['title']))
             # my_log.error(e)
             # 输出日志用这个方法,输出的日志比较详细点
             my_log.exception(e)
             raise e
         else:
             my_log.info("用例--【{}】---执行通过".format(item['title']))
             # 通过门锁类型,来预期录入所耗时间
             if item["lock_type"] == 3:
                 print("请激活门锁,录入开锁信息,45s")
                 time.sleep(45)
                 print("等待结束")
             else:
                 print("请激活门锁22s")
                 time.sleep(10)
                 print("等待结束")
     else:
         my_log.info("用例--【{}】---无需执行".format(item['title']))
Пример #8
0
    def test_nb_new_password(self, item):
        #门锁类型获取
        lock_type = item["lock_type"]
        if lock_type <= self.practical_lock_type:
            #第一步:准备用例数据
            #1)获取请求接口地址
            url = self.base_url + item["url"]
            #2)请求接口参数
            #替换参数IMEI
            if '#IMEI#' in item['data']:
                imei = self.IMEI
                item['data'] = item['data'].replace('#IMEI#', imei)
            #替换参数开始和结束时间
            if "#start_time#" in item["data"]:
                start_time = self.start_time
                item["data"] = item["data"].replace("#start_time#", start_time)

            if "#end_time#" in item["data"]:
                end_time = self.end_time
                item["data"] = item["data"].replace("#end_time#", end_time)
            #测试特殊时间替换
            if "#endTime_expiration#" in item["data"]:
                endTime_expiration = self.endTime_expiration
                item["data"] = item["data"].replace("#endTime_expiration#",
                                                    endTime_expiration)
            if "#to_start_the_start_time#" in item["data"]:
                to_start_the_start_time = self.to_start_the_start_time
                item["data"] = item["data"].replace(
                    "#to_start_the_start_time#", to_start_the_start_time)
            if "#to_start_the_end_time#" in item["data"]:
                to_start_the_end_time = self.to_start_the_end_time
                item["data"] = item["data"].replace("#to_start_the_end_time#",
                                                    to_start_the_end_time)
            #指纹包数据替换
            if "#fingerprint1#" in item["data"]:
                fingerprint1 = self.fingerprint1
                item["data"] = item["data"].replace("#fingerprint1#",
                                                    fingerprint1)
            if "#fingerprint2#" in item["data"]:
                fingerprint2 = self.fingerprint2
                item["data"] = item["data"].replace("#fingerprint2#",
                                                    fingerprint2)
            if "#fingerprint3#" in item["data"]:
                fingerprint3 = self.fingerprint3
                item["data"] = item["data"].replace("#fingerprint3#",
                                                    fingerprint3)
            if "#fingerprint4#" in item["data"]:
                fingerprint4 = self.fingerprint4
                item["data"] = item["data"].replace("#fingerprint4#",
                                                    fingerprint4)
            parms = eval(item["data"])
            #3)请求头
            #类级别前置以获取
            #4)获取请求方法
            method = item["method"].lower()
            #5)用例预期结果
            expected = eval(item["expected"])
            #第二步:请求接口,获取返回实际参数
            response = requests.request(method,
                                        url=url,
                                        json=parms,
                                        headers=self.token)
            res = response.json()
            #第三部:断言
            try:
                self.assertDictIn(expected, res)
                # 成员断言,因为返回的字段不确定性,提取关键字段
            except AssertionError as e:
                # 记录日志
                my_log.error("用例--【{}】---执行失败".format(item['title']))
                # my_log.error(e)
                # 输出日志用这个方法,输出的日志比较详细点
                my_log.exception(e)
                raise e
            else:
                my_log.info("用例--【{}】---执行通过".format(item['title']))
        else:
            my_log.info("用例--【{}】---无需执行".format(item['title']))