二、请求方法封装

这里主要是为了结合输出日志，及测试报告的呈现

 

普通接口请求方法封装

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# @Author   :zaygee
# @time     :2020/12/3 16:30
# @file     :api_method.py
import json
import os

import allure
import jsonpath
import requests

from common import logger
from common.path import RootPath
from config import WEB_LOGIN_URL, LOGIN_DATA, OTHER_LOGIN_DATA

requests.packages.urllib3.disable_warnings()

headers = {
    "Connection": "keep-alive",
    "User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) "
                  "Chrome/58.0.3029.110 Safari/537.36",
    "Content-type": "application/json;charset=UTF-8",
    "Accept": "*/*",
    "DNT": "1",
    "Accept-Encoding": "gzip, deflate, br",
    "Accpet-Language": "zh-CN,zh;q=0.8,en;q=0.6"
}


class BaseRequests:
    """
    封装通用调用方法，支持get、post、put、delete请求
    封装常用请求方法
    """

    def __init__(self):
        self.req = requests.session()
        self.req.headers = headers

    @classmethod
    def _data_to_json(cls, data):
        """
        Args：
            data：接口请求参数/返回参数
        Return：
            美化的json格式数据
        """
        if isinstance(data, str):
            return json.dumps(json.loads(data), indent=4, ensure_ascii=False)
        elif isinstance(data, dict):
            return json.dumps(data, indent=4, ensure_ascii=False)

    @classmethod
    def _api_data_log(cls, data=None, response=None):
        try:
            logger.info('*******用例开始执行～*********')
            if response is not None:
                logger.info('***Request-Url**：' + str(response.url))
                logger.info('******Request-Header**：' + '\n' + str(response.request.headers))
                allure.attach(name="请求接口", body=str(response.url))
                # allure.attach(name="请求头", body=str(response.request.headers))
            if data is not None:
                logger.info('******Request-Content**：' + '\n' + cls._data_to_json(data))
                allure.attach(name="请求参数", body=cls._data_to_json(data))
            else:
                logger.info('******Request-Content***：' + "无请求参数")
                allure.attach(name="请求参数", body=str("无请求参数"))
            if response is not None:
                logger.info('******Response-Code**：' + str(response.status_code))
                logger.info('******Response-Cookie**：' + '\n' + str(response.cookies.get_dict()))
                # allure.attach(name="响应码", body=str(response.status_code))
                # allure.attach(name="响应头cookie", body=str(response.cookies.get_dict()))
                if response.text == '':
                    logger.info('******Response-Content***：' + "无响应参数")
                    allure.attach(name="响应参数", body=str('无响应参数'))
                else:
                    logger.info('******Response-Content**：' + '\n' + cls._data_to_json(response.text))
                    allure.attach(name="响应参数", body=cls._data_to_json(response.text))
            logger.info('*******用例执行结束～*********')
        except ValueError as e:
            raise ValueError(e, '参数不存在，请检查～')

    def post_req(self, url, data=None, **args):
        """
        Args：
            url：post方法的请求URL
            data：请求参数
            args：字典类型的其他传参
        Return
            res：响应参数
        """
        res = self.req.post(url=url, json=data, verify=False, **args)
        self._api_data_log(data=data, response=res, )
        return res

    def get_req(self, url, params=None, **args):
        """
        Args：
            url：get方法的请求URL
            params：请求参数
            args：字典类型的其他传参
        Return
            res：响应参数
        """
        res = self.req.get(url=url, params=params, verify=False, **args)
        self._api_data_log(data=params, response=res)
        return res

    def put_req(self, url, data=None, **kwargs):
        """
        Args：
            url：put方法的请求URL
            params：请求参数
            args：字典类型的其他传参
        Return
            res：响应参数
        """
        res = self.req.put(url=url, json=data, verify=False, **kwargs)
        self._api_data_log(data=data, response=res, )
        return res

    def delete_req(self, url, **kwargs):
        """
        Args：
            url：delete方法的请求URL
            args：字典类型的其他传参
        Return
            res：响应参数
        """
        res = self.req.delete(url=url, verify=False, **kwargs)
        self._api_data_log(response=res)
        return res

    @classmethod
    def get_cookie(cls, url=WEB_LOGIN_URL, data=LOGIN_DATA):
        """
        Args:
            url: r'请求url，默认login url'
            data: r'请求参数，默认 login data'
        Return:
            r'返回响应头cookie'
        """
        res = base.post_req(url=url, data=data)
        try:
            if res.status_code == 200:
                return res.headers['Set-Cookie']
        except BaseException as e:
            raise (e, '获取cookie失败～！')

    @classmethod
    def get_cookie_val(cls, url=WEB_LOGIN_URL, data=LOGIN_DATA):
        """
        Args:
            url: r'请求url，默认login url'
            data: r'请求参数，默认 login data'
        Return:
            r'返回响应头cookie的值'
        """
        res = base.post_req(url=url, data=data)
        try:
            if res.status_code == 200:
                for key, value in res.cookies.get_dict().items():
                    if key.find("authorization") != -1:
                        return value
                    break
        except BaseException as e:
            raise (e, '获取cookie的值失败～！')

    @classmethod
    def get_cookie_key_val(cls, url=WEB_LOGIN_URL, data=LOGIN_DATA):
        """
        Args:
            url: r'请求url，默认login url'
            data: r'请求参数，默认 login data'
        Return:
            r'返回响应头cookie'
        """
        res = base.post_req(url=url, data=data)
        try:
            if res.status_code == 200:
                for key, value in res.cookies.get_dict().items():
                    if key.find("authorization") != -1:
                        return key + '=' + value
                    break
        except BaseException as e:
            raise (e, '获取cookie失败～！')

    @classmethod
    def write_cookie(cls):
        """
        写入两个账号的cookie到json文件
        """
        cookie_file = os.path.join(RootPath.root_path, 'cookie.json')
        with open(cookie_file, 'w', encoding="utf-8") as f:
            cookie = cls.get_cookie_key_val()
            other_cookie = cls.get_cookie_key_val(data=OTHER_LOGIN_DATA)
            cookie = {'cookie': cookie, 'other_cookie': other_cookie}
            json.dump(cookie, f, indent=4)

    @classmethod
    def read_cookie(cls):
        """从json读取读取两个账号的cookie"""
        cookie_file = os.path.join(RootPath.root_path, 'cookie.json')
        with open(cookie_file, 'r', encoding='utf-8') as ff:
            data = ff.read()
            data = json.loads(data)
        return data

    @classmethod
    def write_cookie_value(cls):
        """写入两个账号的cookie的值到json文件"""
        cookie_file = os.path.join(RootPath.root_path, 'cookie_value.json')
        with open(cookie_file, 'w', encoding="utf-8") as f:
            cookie = cls.get_cookie_val()
            other_cookie = cls.get_cookie_val(data=OTHER_LOGIN_DATA)
            cookie = {'value': cookie, 'other_value': other_cookie}
            json.dump(cookie, f, indent=4)

    @classmethod
    def read_cookie_value(cls):
        """从json读取读取两个账号的cookie的值"""

        cookie_file = os.path.join(RootPath.root_path, 'cookie_value.json')
        with open(cookie_file, 'r', encoding='utf-8') as ff:
            data = ff.read()
            data = json.loads(data)
        return data

    @classmethod
    def extract(cls, data, extract):
        """
        Args:
            data:响应参数
            extract: jsonpath提取
            eg：({"code": 0,}, $.code, 0)
        Return:
            提取期望响应参数
        """
        try:
            if data != '':
                result = jsonpath.jsonpath(json.loads(data), extract)
                logger.info("提取响应参数内容：" + str(result))
                return result[0]
        except ValueError as e:
            raise (e, "提取响应参数失败～")


base = BaseRequests()

Websocket接口请求方法封装

# -*- coding: utf-8 -*-#
# file:         socket_method.py
# Author:       zaygee
# Date:         2021/5/17

import allure
import requests
from websocket import create_connection

from common import logger

requests.packages.urllib3.disable_warnings()

header = {
    'Accept-Encoding': 'gzip, deflate, br',
    'Connection': 'keep-alive',
    'Content-Type': 'application/json;charset=UTF-8',
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) '
                  'Chrome/87.0.4280.88 Safari/537.36 '

}


def websocket_log(url=None, ws=None, count=1):
    try:
        logger.info('*******Socket用例开始执行～*********')
        if url is not None:
            logger.info("***Socket请求URL*** ：" + '\n' + str(url))
            allure.attach(name="请求URL", body=str(url))

        if ws:
            logger.info("***连接状态*** ：" + str(ws.status))
            allure.attach(name="连接状态", body=str(ws.status))
            if count is not None:
                for i in range(count):
                    res = ws.recv()
                    logger.info("***下发数据*** ：" + str(res))
                    allure.attach(name=f"下发数据{i}", body=str(res))
                    if i == count - 1:
                        return res
        logger.info('*******Socket用例执行结束～*********')
    except ValueError as e:
        raise (e, 'error!')


class SocketCon:

    @classmethod
    def con(cls, url, cookie=None):
        """
        开始链接
        Args:
            url-->请求url
            cookie-->cookie，默认不传
        Return:
            websocket连接成功对象
        """
        ws = create_connection(url=url, cookie=cookie)
        # websocket.enableTrace(True)
        logger.info('****Socket链接开始****')
        logger.info('***Socket请求Url***:' + '\n' + str(url))
        allure.attach(name=f"请求Url", body=str(url))
        logger.info('***连接状态***:' + str(ws.status))
        return ws

    @staticmethod
    def recv_log(ws, count):
        """
        接收服务端消息并输出日志
        Args:
            ws-->websocket连接成功对象
            count-->接收下发数据次数
        Return:
            最后一次下发数据，主要用于断言
        """
        for i in range(count):
            res = ws.recv()
            logger.info('***下发数据***:' + str(res))
            allure.attach(name=f"下发数据{i}", body=str(res))
            if i == count - 1:
                logger.info("*****Socket链接结束*****")
                return res