接口自动化测试框架设计--demo

接口自动化测试框架设计：

• 接口请求
• 接口类型
• 接口请求数据
• 接口响应
• 预期结果
• 数据依赖（若后一接口请求需要前一接口的响应数据/需要header或cookie等数据传递）
• 测试结果

代码实现逻辑：

1. 首先创建test_data目录，目录下放置请求数据存放的excel表与json文件
2. python操作excel，需要安装两个包，分别是xlrd和xlwt这两个库，xlrd这个库是负责读取excel数据的，而xlwt库是负责向excel写入数据的
3. 在项目目录下创建utils工具包，在该包下创建op_excel.py文件，在该文件中通过导入xlrd包，对excel表的数据进行读取操作

from copy import copy

import xlrd,xlwt


class operationExcel(object):
    def __init__(self, file_path="/Users/wy_pc/Documents/pythonProject/autotest/test-data/test-data.xlsx", sheet_id=0):
        self.file_path = file_path
        self.sheet_id = sheet_id
        self.data = self.get_data()

    def get_data(self):
        data = xlrd.open_workbook(self.file_path)
        tables = data.sheets()[self.sheet_id]
        return tables

    def get_rows(self):
        '''获取表格排数'''
        return self.data.nrows

    def get_cell_values(self, x=0, y=0):
        '''获取表格数据'''
        # print("x==",x)
        # print("rrr===",self.data.cell_value(x,y))
        return self.data.cell_value(x, y)

    def write_reality_result_data(self, x, y, data):
        read_data = xlrd.open_workbook(self.file_path)
        tables = read_data.get_sheet(0)
        print("00000==",tables)
        write_data = copy(read_data)
        print(write_data)
        sheet=write_data.get_sheet(0)
        sheet.write(x,y,data)
        print(x)
        print(y)
        #sheet_data.write(x, y, data)
        write_data.save(self.file_path)


if __name__ == '__main__':
    print(operationExcel().get_data())
    # print(operationExcel().get_cell_values())
    print(operationExcel().write_reality_result_data(1,11,"pass"))

 4、操作json文件

import json

class operationJson(object):
    def __init__(self,file_path="/Users/wy_pc/Documents/pythonProject/autotest/test-data/login.json"):
        self.file_path=file_path
        self.data=self.get_data()

    def get_data(self):
        with open(self.file_path) as f:
            data=json.load(f)
            return  data

    def get_key_words(self,key=None):
        ###通过excel的key来获取json文件中的数据
        if key:
            return self.data[key]
        else:
            return self.data

if __name__=='__main__':
    print(operationJson().get_key_words())
    print(operationJson().get_key_words("login"))
    #print(operationJson().get_key_words("login")["username"])

5、对op_excel.py与op_json.py进行封装为data_get有利用代码扩展与维护，同时对excel表的字段进行获取，将每列对应字段定义在data_conf.py

data_conf.py
class global_var:
    id=0 #id
    module=1 #模块
    url=2  #url
    run=3  #是否运行
    resquest_type=4 #请求类型
    resuest_header=5 #是否携带header
    case_depend=6   #case依赖
    response_data_depend=7  #依赖的返回数据
    data_depend=8   #数据依赖
    request_data=9  #请求数据
    except_result=10  #预期结果
    reality_result=11   #实际结果


def get_id():
    return global_var.id
def get_module():
    return global_var.module

def get_url():
    return global_var.url

def get_run():
    return global_var.run

def get_request_type():
    return global_var.resquest_type

def get_request_header():
    return global_var.resuest_header

def get_case_depend():
    return global_var.case_depend

def get_response_data_depend():
    return global_var.response_data_depend

def get_data_depend():
    return global_var.data_depend

def get_request_data():
    return global_var.request_data

def get_expect_data():
    return global_var.except_result

def get_reslity_result():
    return global_var.reality_result

data_get.py
from autotest.utils.op_excel import operationExcel
from autotest.utils.op_json import operationJson
from autotest.data import data_conf


class getData(object):
    def __init__(self):
        self.op_excel = operationExcel()

    def get_case_lines(self):
        """获取表格行数"""
        return self.op_excel.get_rows()

    def get_is_run(self, x):
        """获取case是否运行"""
        flag = None
        y = data_conf.get_run()
        run_value = self.op_excel.get_cell_values(x, y)
        print("run==",run_value)
        if (run_value == 'yes'):
            flag = True
        else:
            flag = False
        return flag

    def get_is_header(self, x):
        """是否携带header"""
        y = data_conf.get_request_header()
        header = self.op_excel.get_cell_values(x, y)
        if (header == 'yes'):
            return data_conf.get_request_header()
        else:
            return None

    def get_request_method(self, x):
        """获取请求方式"""
        y = data_conf.get_request_type()
        request_method = self.op_excel.get_cell_values(x, y)
        return request_method

    def get_request_url(self, x):
        """获取请求方式"""
        y = int(data_conf.get_url())
        print("y===",y)
        request_url = self.op_excel.get_cell_values(x, y)
        print("request_url==",request_url)
        return request_url

    def get_request_data(self, x):
        """获取返回数据"""
        y = data_conf.get_request_data()
        request_data = self.op_excel.get_cell_values(x, y)
        if (request_data == ""):
            return None
        return request_data

    def get_data_for_json(self, x):
        """通过excel关键字去获取json数据"""
        op_json = operationJson()
        data = op_json.get_key_words(self.get_request_data(x))
        return data

    def get_expect_data(self, x):
        """获取预期结果"""
        y = data_conf.get_expect_data()
        expect_data = self.op_excel.get_cell_values(x, y)
        if (expect_data == ""):
            return None
        return expect_data

    def get_module_name(self,x):
        """获取模块名"""
        y=int(data_conf.get_module())
        module_name=self.op_excel.get_cell_values(x,y)
        return module_name

    def write_reality_data(self,x,data):
        y=int(data_conf.get_reslity_result())
        print("y===",y)
        self.op_excel.write_reality_result_data(x,y,data)

6、对post/get请求进行封装

run_methodpy.
import requests
import mock

class RunMain(object):
    def get_main(self,url,data=None,header=None):
        res=None
        #if(header is not None):
            #res=requests.get(url=url,data=data,header=header).json()

        #else:
            #res = requests.get(url=url, data=data).status_code
        res=200
        return res

    def post_main(self,url,data,header=None):
        res=None
        if(header is not None):
            res=requests.post(url=url,data=data,header=header).json()

        else:
            res = requests.post(url=url, data=data).json()

        return res

    def run_main(self,url,method,data=None,header=None):
        res = None
        if(method.lower()=="get"):
            data=None
            res=self.get_main(url,data,header)
        elif(method.lower()=="post"):
            res=self.post_main(url,data,header)
            #res = {"status": 200}
        else:
            return "method error"
        return res

7、预期结果与实际结果断言

common_util.py
import json


class CommonUtil(object):
    def is_contains(self, expect, reality):
        flag = None
        #reality = json.loads(reality)
        expect = json.loads(expect)
        if expect['status'] == reality:
            flag = True
        else:
            flag = False
        return flag

8、主函数

from autotest.base.run_method import RunMain
from autotest.data.data_get import getData
from autotest.utils.common_util import CommonUtil

class RunTest(object):
    def __init__(self):
        self.runmain=RunMain()
        self.data=getData()
        self.CommonUtil=CommonUtil()

    def run(self):
        res=None
        rows_counts=self.data.get_case_lines()

        for row_count in range(1,rows_counts):
            print("rows_counts==",row_count)
            url=self.data.get_request_url(row_count)
            method=self.data.get_request_method(row_count)
            is_run=self.data.get_is_run(row_count)
            data=self.data.get_data_for_json(row_count)
            header=self.data.get_is_header(row_count)
            module=self.data.get_module_name(row_count)
            expect=self.data.get_expect_data(row_count)
            print('url',url)
            print('method',method)
            print('is_run',is_run)
            print('data',data)
            print('header',header)
            print("module",module)
            print("expect",expect)

            if is_run:
                res=self.runmain.run_main(url,method,data,header)
                print("res===",res)
                print("*"*60+"分割线"+"*"*60)
                if self.CommonUtil.is_contains(expect,res):
                    print("pass")
                    self.data.write_reality_data(row_count,"pass")
                else:
                    print("error")
                    self.data.write_reality_data(row_count, "error")

        return res
if __name__=='__main__':
    print('res:',RunTest().run())