apiobject模式(学习代码：部门管理增删改查自动化测试框架）

1.代码目录

    -接口测试po模式训练
      -api
        -__init__.py
        -department.py
        -firstwork.py
        -baseapi.py
      -data
        -config.yml
      -interface
        -__init__.py
        -test_department.py
        -utils.py
      -logs
        apitest.log 

2.代码

api代码

baseapi.py

class BaseApi:
    #设置logging
    fileHandler = logging.FileHandler(filename="../logs/apitest.log")
    #设置日志等级
    logging.getLogger().setLevel(0)
    #设置日志内容格式
    formatter = logging.Formatter('%(asctime)s %(name)s %(levelname)s %(module)s:%(lineno)d %(message)s')
    fileHandler.setFormatter(formatter)
    #设置生效
    logging.getLogger().addHandler(fileHandler)

    def log_info(self,msg):
        '''
        写日志的方法
        :param msg: 要打印都日志的信息
        :return: info级别的日志
        '''
        return logging.info(msg)

    def send_api(self,req):
        '''
        对requests进行二次封装
        :param req:
        :return:返回接口响应结果
        '''
        self.log_info("----------request data----------")
        self.log_info(req)
        r = requests.request(**req)
        self.log_info("----------response data----------")
        self.log_info(r.json())
        return requests.request(**req)

firstWork.py

'''
企业微信调用部门接口前，需要信息认证
'''
import requests
import pytest

from 接口测试po模式训练.api.send_api import BaseApi


class firstWork(BaseApi):

    def __init__(self, corpid, corpsecret):
        self.token = self.get_access_token(corpid, corpsecret)

    def get_access_token(self,corpid,corpsecret):

        '''
        获取access_token
        :return:
        '''

        # corpid = "ww02f9f41e1958d910"
        # corpsecret = "v_xbPx4VWhwQkiz7lZz3JJWcPH_WQOly3UvfTYZjyHo"
        # 请求地址
        url =f" https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid={corpid}&corpsecret={corpsecret}"


        #把接口封装到字典中
        req = {
            "method": "GET",
            "url": url,

        }
        # 调用方法对字典解包，发出get请求(原始响应结果)
        r = self.send_api(req)
        print(r.json())
        token = r.json()["access_token"]
        return token

department.py

'''
接口信息描述：不加断言，不加测试数据，只写方法
每个方法需返回接口响应体
'''
import requests

from 接口测试po模式训练.api.firstWork import firstWork
from 接口测试po模式训练.interface.utils import Utils


class Department(firstWork):

    #描述接口方法时，将测试数据以参数形式展示，方便后面测试脚本调用接口中的方法进行传参测试
    def create_department(self,create_data):
        '''
        创建部门
        :return:
        '''
        params = {
            "access_token": self.token
        }

        create_url = 'https://qyapi.weixin.qq.com/cgi-bin/department/create'
        # 发送请求
        #r1 = requests.post(create_url, params=params, json=create_data)
        #把接口内容封装到字典里面
        req = {
            "method": "POST",
            "url": create_url,
            "params": params,
            "json": create_data
        }
        #调用接口封装方法解包接口，发出请求
        r = self.send_api(req)
        print(r.json())
        return r.json()

    def update_department(self,update_data):
        '''
        更新部门
        :return:
        '''
        update_url = f"https://qyapi.weixin.qq.com/cgi-bin/department/update?access_token={self.token}"

        #r2 = requests.post(update_url, json=update_data)
        #把接口内容进行封装
        req = {
            "method": "POST",
            "url": update_url,
            "json": update_data
        }
        #调用封装方法解包接口内容，发出请求
        r = self.send_api(req)
        return r.json()

    def get_department(self):
        '''
        获取部门
        :return:
        '''
        get_data ={

        }
        get_url = f'https://qyapi.weixin.qq.com/cgi-bin/department/list?access_token={self.token}'

        #r3 = requests.get(get_url, params=get_data)
        #把接口内容进行封装
        req ={
            "method":"GET",
            "url": get_url,
            "params":get_data
        }

        #调用接口封装方法对接口内容进行解包
        r = self.send_api(req)

        return r.json()

    def delete_department(self,depart_id):
        '''
        删除部门
        :return:
        '''
        url = 'https://qyapi.weixin.qq.com/cgi-bin/department/delete'
        params = {
            "access_token":self.token,
            "id":depart_id
        }
        #r4 = requests.get(url, params)

        #把接口内容进行封装
        req = {
            "method": "GET",
            'params': params,
            "url": url
        }
        #调用接口函数对接口内容进行解包，发送请求
        r = self.send_api(req)
        return r.json()

    def clear_department(self):
        '''
        清理已经存在的部门
        :return:
        '''

        #查询当前存在的部门
        depart_list = self.get_department()
        #提取部门id
        id_list = Utils.base_jsonpath(depart_list,"$..id")
        #id 为1 的最基础的父部门，不能删除
        for i in id_list:
            if i !=1:
                #调用删除部门的接口完成清除操作
                self.delete_department(i)

测试代码

utils.py

# -*- coding:UTF-8 -*-
'''
@Project : 607project
@file : utils.PY
@Date : 2021/10/18 11:53
@Author : Fairy
'''
import yaml
from jsonpath import jsonpath


class Utils:

    @classmethod
    def base_jsonpath(cls, obj, json_expr):
        '''
        封装jsonpath断言方法
        :param obj: 要断言的json格式的响应内容
        :param json_expr: jsonpath表达式
        :return: 断言结果
        '''
        return jsonpath(obj, json_expr)

    @classmethod
    def get_yaml_data(cls, file_path):
        '''
        封装yaml文件读取方法
        :param file_path:yaml文件路径
        :return:返回字典格式yaml文件
        '''

        with open(file_path) as f :
            datas =yaml.safe_load(f)

        return datas

test_department.py

'''
测试用例
'''
from 接口测试po模式训练.api.department import Department
from 接口测试po模式训练.interface.utils import Utils
import allure
import pytest

'''
第一版框架
1.根据ApiObject模式完成了分层
2.从firstWork中获取token,department中描述接口完成身份认证
3.测试用例中通过setup_class实例化接口描述的类
4.测试用例中传入测试数据，完成断言
'''
@allure.feature("部门管理")
class TestDepartment:

    def setup_class(self):
        #获取通讯录管理的token参数
        conf_data = Utils.get_yaml_data("../data/config.yml")
        corpid = conf_data["corpid"]["qiyeceshi"]
        corpsecret = conf_data["secret"]["department_secret"]


        #实例化部门类
        self.department = Department(corpid, corpsecret)
        #清除部门数据
        self.department.clear_department()

        #准备测试数据
        #创建部门的测试数据
        self.depart_id = 5

        self.create_data = {
            "name": "天津研发中心",
            "name_en": "TJ",
            "order": 11,
            "id": self.depart_id,
            "parentid": 1
        }


        #更新部门的测试数据

        self.update_data = {
            "id": self.depart_id,
            "name": "天津研发中心——更新"
        }

        # self.delete_data = {
        #     "id": self.depart_id
        # }
    @allure.story("部门操作场景用例")
    def test_department_scene(self):
        '''
        部门增删改查测试
        :return:
        '''
        # 创建部门
        with allure.step("创建部门"):
            self.department.create_department(self.create_data)

        #查询创建是否成功
        with allure.step("查询部门创建结果"):
            res1 = self.department.get_department()
            #assert res1["department"][6]["name"] == "天津研发中心"

            #通过jsonpath断言
            name_list = Utils.base_jsonpath(res1,"$..name")
            print(name_list)
            assert "天津研发中心" in name_list
            print(res1)

        # 更新部门
        with allure.step("更新部门"):
            self .department.update_department(self.update_data)

        # #查询更新是否成功
        with allure.step("查询部门更新结果"):
            res2 = self.department.get_department()
            #assert res2["department"][3]["name"]=="天津研发中心——更新"

            #通过jsonpath断言
            name_list = Utils.base_jsonpath(res2,"$..name")
            print(name_list)
            assert "天津研发中心——更新" in name_list

        # 删除部门
        with allure.step("删除部门"):
            self.department.delete_department(self.depart_id)

        #查询删除是否成功（通过验证删除一个部门后，部门列表的长度）
        with allure.step("查询部门删除结果"):
            res3 = self.department.get_department()
            #assert len(res3["department"])==4

            #通过jsonpath断言
            id_list = Utils.base_jsonpath(res3,"$..id")
            #操作的部门id删除后不在部门id列表中
            assert self.depart_id not in id_list