case执行的数据依赖

数据依赖之设计思路

一般情况下，我们在执行测试用例时，经常遇到当前接口的入参会依赖其它接口的返回数据。如：商品列表到商品详情，商品详情接口会用到商品列表接口生成的商品id，这种接口参数之间相互依赖的关系就称之为数据依赖。

那么在设计测试用例时数据依赖的关系将如何处理呢？

首先需要用到的三个字段：依赖id、依赖的返回数据字段、依赖所属字段。通过“依赖id”单元格内容找到case_id行对应内容，然后去执行获取请求返回结果根据，再根据我们依赖的返回数据去把对应的值提取出来更新一下作为当前接口的请求参数执行，以商品列表、商品详情为例：

依赖返回数据.png 依赖关系.png

如图：SC004需要依赖SC002热销商品列表接口返回数据id,将依赖返回数据id更新到数据依赖所属字段（SC004请求入参字段id）中

数据依赖方法封装

思路：通过“依赖id”单元格内容找到case_id行对应内容。

步骤1：新创建一个类dependent_data.py，用于处理所有数据依赖的相关问题

# coding:utf-8
class DependentData:
     """
     通过case_id去获取该case_id的整行数据
     """
     def get_case_line_data(self,case_id):
          pass

步骤2:操作excle，在operation_excel.py包含里面去获取excle数据，首先通过数据依赖找到case_id,通过循环找到case_id对应行号拿到对应行的内容。

 #根据对应caseid 找到对应行的内容
    def get_row_data(self,case_id):
        row_num = self.get_row_num(case_id) #根据case_id拿到行行号
        rows_data = self.get_row_valuse(row_num) #根据行号拿到该行内容
        return rows_data

    #根据对应的caseid找到对应的行号
    def get_row_num(self,case_id):
        num = 0
        #获取case_id列的内容
        clols_data = self.get_cols_data()
        for col_data in clols_data:
            if case_id in col_data:
                return num
            num = num + 1

    #根据行号，找到该行的内容
    def get_row_valuse(self,row):
        tables = self.data
        #获取行内容
        row_data = tables.row_values(row)
        return row_data

    #获取某一列的内容
    def get_cols_data(self,col_id=None):
        if col_id!=None:
            cols = self.data.col_values(col_id)
        else:
            cols = self.data.col_values(0)
        return cols

数据依赖根据规则提取响应数据

上面实现了如何根据case_id取到对应行的内容，把操作excel方法拿过来用,操作excel的方法：

# coding:utf-8
#导入excle操作
from util.operation_excel import OperationExcel
class DependentData:
     def __init__(self,case_id):
          self.case_id = case_id #传case_id
          self.opera_excle =OperationExcel() #实例化    
     """
     通过case_id去获取该case_id的整行数据
     """
     def get_case_line_data(self):
          rows_data = self.opera_excle.get_row_data(self.case_id)
          return rows_data

有了整行的内容后，就需要去执行里面的内容，那么怎么去执行呢？

将需要用到的方法导入，并实例化

from  base.runmethod import RunMethod
from  data.get_data import GetData
class DependentData:
     def __init__(self,case_id):
          self.data = GetData()#获取数据实例化

执行依赖测试，获取结果

 #执行依赖测试，获取结果
     def run_dependent(self):
          run_method = RunMethod()#实例化
          row_num = self.opera_excle.get_row_num(self.case_id) #获取行号
          request_data = self.data.get_data_for_json(row_num) #传入行号
          header = self.data.is_header(row_num)
          method = self.data.get_request_method(row_num)
          url = self.data.get_request_url(row_num)
          res = run_method.run_main(method,url,request_data,header)
          return res

执行完成后，只需把执行完成返回的结果根据我们的依赖数据去把对应的值提取出来，那么怎么去提取对应的值呢？

步骤1：在get_data.py中新增获取依赖数据key的方法

# 获取依赖数据的key
    def get_depend_key(self,row):
        col = int(data.data_config.get_data_depend())
        depent_key = self.opera_excle.get_cell_value(row,col)
        if depent_key == "":
            return None
        else:
            return depent_key

步骤2：在dependent_data.py中依赖的key去获取执行依赖测试case的响应数据，然后返回。使用jsonpath解析json参考：https://www.jianshu.com/p/82e63cc8e0a1

from jsonpath_rw import jsonpath,parse

      #根据依赖的key去获取执行依赖测试case的响应数据，然后返回
     def get_data_for_key(self,row):
          depend_data = self.data.get_depend_key(row)
          response_data = self.run_dependent() #拿到响应值，根据层级关系去拿对应的值
          print(depend_data)
          print(response_data)
          #用到jsonpath(就是一层一层的去拿数据)
          json_exe = parse('depend_data')
          madle = json_exe.find(response_data)
          return [math.value for math in madle]#结果集里返回对应数据

数据依赖结构构建

通过case返回的数据把对应数据拿到之后，接下来就需要把数据拿过来更新一下作为请求数据。

步骤一：首先判断要不要执行即判断有没有依赖（拿返回数据去判断），获取depend数据，在get_data.py下创建一个方法

#判断是否有case依赖
    def is_depend(self,row):
        col = int(data.data_config.get_case_depend())#获取依赖所属字段
        depend_case_id = self.opera_excle.get_cell_value(row,col)#拿到对应数据
        if depend_case_id == "":
            return None
        else:
            return depend_case_id

步骤二：架子搭建，在run_test.py中传入数据依赖

import sys
sys.path.append("F:/project/untitled")
from base.runmethod import RunMethod
from data.get_data import GetData
from util.common_util import CommonUtil
from data.dependent_data import DependentData
class RunTest:
    def __init__(self):
        self.run_method = RunMethod()
        self.data = GetData()
        self.com_until = CommonUtil()

    # 程序执行主入口
    def go_on_run(self):
        res = None
        # 获取excel行数，即case个数
        rows_count = self.data.get_case_lines()
        # 循环执行case
        for i in range(1,rows_count):
            is_run = self.data.get_is_run(i)
            if is_run:
                 url = self.data.get_request_url(i)
                 method = self.data.get_request_method(i)
                 request_data = self.data.get_data_for_json(i)  # 请求数据存放在json文件
                 expect = self.data.get_expect_data(i) # 获取预期结果值
                 header = self.data.is_header(i)
                 depend_case = self.data.is_depend(i)

            #如果depend_case!=None就需要有依赖
            if depend_case !=None:
                self.depend_data = DependentData(depend_case)
                #获取依赖的响应数据
                depend_response_data = self.depend_data.get_data_for_key(i) #传入行号
                #获取依赖的key
                depend_key = self.data.get_depend_field(i)
                #根据获取的依赖key把字段更新下
                request_data[depend_key] = depend_response_data
            res = self.run_method.run_main(method, url, request_data, header)
            if self.com_until.is_contain(expect,res):
                self.data.write_result(i,'pass')
            else:
                self.data.write_result(i,'fail')
if __name__ == '__main__':
    run = RunTest()
    run.go_on_run()

在get_data.py中定义获取依赖字段的方法

 #获取数据依赖字段
    def get_depend_field(self,row):
        col = int(data.data_config.get_filed_depend())
        depend_data = self.opera_excle.get_cell_value(row,col)
        if depend_data =="":
            return  None
        else:
            return depend_data

执行结果.png