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

普通接口请求方法封装

  1. #!/usr/bin/python
  2. # -*- coding: UTF-8 -*-
  3. # @Author   :zaygee
  4. # @time     :2020/12/3 16:30
  5. # @file     :api_method.py
  6. import json
  7. import os
  9. import allure
  10. import jsonpath
  11. import requests
  13. from common import logger
  14. from common.path import RootPath
  15. from config import WEB_LOGIN_URL, LOGIN_DATA, OTHER_LOGIN_DATA
  17. requests.packages.urllib3.disable_warnings()
  19. headers = {
  20.     "Connection": "keep-alive",
  21.     "User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) "
  22.                   "Chrome/58.0.3029.110 Safari/537.36",
  23.     "Content-type": "application/json;charset=UTF-8",
  24.     "Accept": "*/*",
  25.     "DNT": "1",
  26.     "Accept-Encoding": "gzip, deflate, br",
  27.     "Accpet-Language": "zh-CN,zh;q=0.8,en;q=0.6"
  28. }
  31. class BaseRequests:
  32.     """
  33.     封装通用调用方法，支持get、post、put、delete请求
  34.     封装常用请求方法
  35.     """
  37.     def __init__(self):
  38.         self.req = requests.session()
  39.         self.req.headers = headers
  41.     @classmethod
  42.     def _data_to_json(cls, data):
  43.         """
  44.         Args：
  45.             data：接口请求参数/返回参数
  46.         Return：
  47.             美化的json格式数据
  48.         """
  49.         if isinstance(data, str):
  50.             return json.dumps(json.loads(data), indent=4, ensure_ascii=False)
  51.         elif isinstance(data, dict):
  52.             return json.dumps(data, indent=4, ensure_ascii=False)
  54.     @classmethod
  55.     def _api_data_log(cls, data=None, response=None):
  56.         try:
  57.             logger.info('*******用例开始执行～*********')
  58.             if response is not None:
  59.                 logger.info('***Request-Url**：' + str(response.url))
  60.                 logger.info('******Request-Header**：' + '\n' + str(response.request.headers))
  61.                 allure.attach(name="请求接口", body=str(response.url))
  62.                 # allure.attach(name="请求头", body=str(response.request.headers))
  63.             if data is not None:
  64.                 logger.info('******Request-Content**：' + '\n' + cls._data_to_json(data))
  65.                 allure.attach(name="请求参数", body=cls._data_to_json(data))
  66.             else:
  67.                 logger.info('******Request-Content***：' + "无请求参数")
  68.                 allure.attach(name="请求参数", body=str("无请求参数"))
  69.             if response is not None:
  70.                 logger.info('******Response-Code**：' + str(response.status_code))
  71.                 logger.info('******Response-Cookie**：' + '\n' + str(response.cookies.get_dict()))
  72.                 # allure.attach(name="响应码", body=str(response.status_code))
  73.                 # allure.attach(name="响应头cookie", body=str(response.cookies.get_dict()))
  74.                 if response.text == '':
  75.                     logger.info('******Response-Content***：' + "无响应参数")
  76.                     allure.attach(name="响应参数", body=str('无响应参数'))
  77.                 else:
  78.                     logger.info('******Response-Content**：' + '\n' + cls._data_to_json(response.text))
  79.                     allure.attach(name="响应参数", body=cls._data_to_json(response.text))
  80.             logger.info('*******用例执行结束～*********')
  81.         except ValueError as e:
  82.             raise ValueError(e, '参数不存在，请检查～')
  84.     def post_req(self, url, data=None, **args):
  85.         """
  86.         Args：
  87.             url：post方法的请求URL
  88.             data：请求参数
  89.             args：字典类型的其他传参
  90.         Return
  91.             res：响应参数
  92.         """
  93.         res = self.req.post(url=url, json=data, verify=False, **args)
  94.         self._api_data_log(data=data, response=res, )
  95.         return res
  97.     def get_req(self, url, params=None, **args):
  98.         """
  99.         Args：
  100.             url：get方法的请求URL
  101.             params：请求参数
  102.             args：字典类型的其他传参
  103.         Return
  104.             res：响应参数
  105.         """
  106.         res = self.req.get(url=url, params=params, verify=False, **args)
  107.         self._api_data_log(data=params, response=res)
  108.         return res
  110.     def put_req(self, url, data=None, **kwargs):
  111.         """
  112.         Args：
  113.             url：put方法的请求URL
  114.             params：请求参数
  115.             args：字典类型的其他传参
  116.         Return
  117.             res：响应参数
  118.         """
  119.         res = self.req.put(url=url, json=data, verify=False, **kwargs)
  120.         self._api_data_log(data=data, response=res, )
  121.         return res
  123.     def delete_req(self, url, **kwargs):
  124.         """
  125.         Args：
  126.             url：delete方法的请求URL
  127.             args：字典类型的其他传参
  128.         Return
  129.             res：响应参数
  130.         """
  131.         res = self.req.delete(url=url, verify=False, **kwargs)
  132.         self._api_data_log(response=res)
  133.         return res
  135.     @classmethod
  136.     def get_cookie(cls, url=WEB_LOGIN_URL, data=LOGIN_DATA):
  137.         """
  138.         Args:
  139.             url: r'请求url，默认login url'
  140.             data: r'请求参数，默认 login data'
  141.         Return:
  142.             r'返回响应头cookie'
  143.         """
  144.         res = base.post_req(url=url, data=data)
  145.         try:
  146.             if res.status_code == 200:
  147.                 return res.headers['Set-Cookie']
  148.         except BaseException as e:
  149.             raise (e, '获取cookie失败～！')
  151.     @classmethod
  152.     def get_cookie_val(cls, url=WEB_LOGIN_URL, data=LOGIN_DATA):
  153.         """
  154.         Args:
  155.             url: r'请求url，默认login url'
  156.             data: r'请求参数，默认 login data'
  157.         Return:
  158.             r'返回响应头cookie的值'
  159.         """
  160.         res = base.post_req(url=url, data=data)
  161.         try:
  162.             if res.status_code == 200:
  163.                 for key, value in res.cookies.get_dict().items():
  164.                     if key.find("authorization") != -1:
  165.                         return value
  166.                     break
  167.         except BaseException as e:
  168.             raise (e, '获取cookie的值失败～！')
  170.     @classmethod
  171.     def get_cookie_key_val(cls, url=WEB_LOGIN_URL, data=LOGIN_DATA):
  172.         """
  173.         Args:
  174.             url: r'请求url，默认login url'
  175.             data: r'请求参数，默认 login data'
  176.         Return:
  177.             r'返回响应头cookie'
  178.         """
  179.         res = base.post_req(url=url, data=data)
  180.         try:
  181.             if res.status_code == 200:
  182.                 for key, value in res.cookies.get_dict().items():
  183.                     if key.find("authorization") != -1:
  184.                         return key + '=' + value
  185.                     break
  186.         except BaseException as e:
  187.             raise (e, '获取cookie失败～！')
  189.     @classmethod
  190.     def write_cookie(cls):
  191.         """
  192.         写入两个账号的cookie到json文件
  193.         """
  194.         cookie_file = os.path.join(RootPath.root_path, 'cookie.json')
  195.         with open(cookie_file, 'w', encoding="utf-8") as f:
  196.             cookie = cls.get_cookie_key_val()
  197.             other_cookie = cls.get_cookie_key_val(data=OTHER_LOGIN_DATA)
  198.             cookie = {'cookie': cookie, 'other_cookie': other_cookie}
  199.             json.dump(cookie, f, indent=4)
  201.     @classmethod
  202.     def read_cookie(cls):
  203.         """从json读取读取两个账号的cookie"""
  204.         cookie_file = os.path.join(RootPath.root_path, 'cookie.json')
  205.         with open(cookie_file, 'r', encoding='utf-8') as ff:
  206.             data = ff.read()
  207.             data = json.loads(data)
  208.         return data
  210.     @classmethod
  211.     def write_cookie_value(cls):
  212.         """写入两个账号的cookie的值到json文件"""
  213.         cookie_file = os.path.join(RootPath.root_path, 'cookie_value.json')
  214.         with open(cookie_file, 'w', encoding="utf-8") as f:
  215.             cookie = cls.get_cookie_val()
  216.             other_cookie = cls.get_cookie_val(data=OTHER_LOGIN_DATA)
  217.             cookie = {'value': cookie, 'other_value': other_cookie}
  218.             json.dump(cookie, f, indent=4)
  220.     @classmethod
  221.     def read_cookie_value(cls):
  222.         """从json读取读取两个账号的cookie的值"""
  224.         cookie_file = os.path.join(RootPath.root_path, 'cookie_value.json')
  225.         with open(cookie_file, 'r', encoding='utf-8') as ff:
  226.             data = ff.read()
  227.             data = json.loads(data)
  228.         return data
  230.     @classmethod
  231.     def extract(cls, data, extract):
  232.         """
  233.         Args:
  234.             data:响应参数
  235.             extract: jsonpath提取
  236.             eg：({"code": 0,}, $.code, 0)
  237.         Return:
  238.             提取期望响应参数
  239.         """
  240.         try:
  241.             if data != '':
  242.                 result = jsonpath.jsonpath(json.loads(data), extract)
  243.                 logger.info("提取响应参数内容：" + str(result))
  244.                 return result[0]
  245.         except ValueError as e:
  246.             raise (e, "提取响应参数失败～")
  249. base = BaseRequests()

Websocket接口请求方法封装

  1. # -*- coding: utf-8 -*-#
  2. # file:         socket_method.py
  3. # Author:       zaygee
  4. # Date:         2021/5/17
  6. import allure
  7. import requests
  8. from websocket import create_connection
  10. from common import logger
  12. requests.packages.urllib3.disable_warnings()
  14. header = {
  15.     'Accept-Encoding': 'gzip, deflate, br',
  16.     'Connection': 'keep-alive',
  17.     'Content-Type': 'application/json;charset=UTF-8',
  18.     'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) '
  19.                   'Chrome/87.0.4280.88 Safari/537.36 '
  21. }
  24. def websocket_log(url=None, ws=None, count=1):
  25.     try:
  26.         logger.info('*******Socket用例开始执行～*********')
  27.         if url is not None:
  28.             logger.info("***Socket请求URL*** ：" + '\n' + str(url))
  29.             allure.attach(name="请求URL", body=str(url))
  31.         if ws:
  32.             logger.info("***连接状态*** ：" + str(ws.status))
  33.             allure.attach(name="连接状态", body=str(ws.status))
  34.             if count is not None:
  35.                 for i in range(count):
  36.                     res = ws.recv()
  37.                     logger.info("***下发数据*** ：" + str(res))
  38.                     allure.attach(name=f"下发数据{i}", body=str(res))
  39.                     if i == count - 1:
  40.                         return res
  41.         logger.info('*******Socket用例执行结束～*********')
  42.     except ValueError as e:
  43.         raise (e, 'error!')
  46. class SocketCon:
  48.     @classmethod
  49.     def con(cls, url, cookie=None):
  50.         """
  51.         开始链接
  52.         Args:
  53.             url-->请求url
  54.             cookie-->cookie，默认不传
  55.         Return:
  56.             websocket连接成功对象
  57.         """
  58.         ws = create_connection(url=url, cookie=cookie)
  59.         # websocket.enableTrace(True)
  60.         logger.info('****Socket链接开始****')
  61.         logger.info('***Socket请求Url***:' + '\n' + str(url))
  62.         allure.attach(name=f"请求Url", body=str(url))
  63.         logger.info('***连接状态***:' + str(ws.status))
  64.         return ws
  66.     @staticmethod
  67.     def recv_log(ws, count):
  68.         """
  69.         接收服务端消息并输出日志
  70.         Args:
  71.             ws-->websocket连接成功对象
  72.             count-->接收下发数据次数
  73.         Return:
  74.             最后一次下发数据，主要用于断言
  75.         """
  76.         for i in range(count):
  77.             res = ws.recv()
  78.             logger.info('***下发数据***:' + str(res))
  79.             allure.attach(name=f"下发数据{i}", body=str(res))
  80.             if i == count - 1:
  81.                 logger.info("*****Socket链接结束*****")
  82.                 return res