pytest-api-framework-alpha 0.1.0__py3-none-any.whl

framework/db/mysql_db.py

@@ -0,0 +1,111 @@
+import pymysql
+from dbutils.pooled_db import PooledDB
+
+from framework.utils.log_util import logger
+import json
+from datetime import datetime
+from decimal import Decimal
+
+
+class MysqlDB(object):
+
+    def __init__(self, host, username, password, port, db):
+
+        self.pool = PooledDB(
+            creator=pymysql,
+            maxconnections=1,
+            mincached=1,
+            maxcached=1,
+            blocking=True,
+            maxusage=None,
+            setsession=[],
+            ping=0,
+            host=host,
+            user=username,
+            password=password,
+            db=db,
+            port=port,
+            charset='utf8'
+        )
+
+    def query(self, sql):
+        """查询，返回结果"""
+        connection = self.pool.connection()  # 获取一个连接
+        cursor = connection.cursor(pymysql.cursors.DictCursor)
+        try:
+            cursor.execute(sql)
+            logger.info(f"执行SQL: {sql}")
+            result = cursor.fetchall()
+            if len(result) == 1:
+                result = result[0]
+            elif len(result) == 0:
+                result = None
+            if isinstance(result, dict) or isinstance(result, list):
+                logger.info(f"SQL执行结果: {json.dumps(result, default=MysqlDB.custom_serializer)}")
+            else:
+                logger.info(f"SQL执行结果: {result}")
+            return result
+        except pymysql.MySQLError as e:
+            logger.error(f"Error executing query: {e}")
+            return None
+        finally:
+            cursor.close()  # 关闭游标
+            connection.close()  # 将连接返回到连接池
+
+    def insert(self, sql):
+        """修改，新增，删除"""
+        connection = self.pool.connection()  # 获取一个连接
+        cursor = connection.cursor(pymysql.cursors.DictCursor)
+        try:
+            result = cursor.execute(sql)
+            connection.commit()
+            inserted_id = cursor.lastrowid
+            print(f"插入的记录的主键ID: {inserted_id}")
+            return inserted_id
+        except pymysql.MySQLError as e:
+            print(e)
+            return None
+        finally:
+            cursor.close()  # 关闭游标
+            connection.close()  # 将连接返回到连接池
+
+    def execute(self, sql):
+        """修改，新增，删除"""
+        connection = self.pool.connection()  # 获取一个连接
+        cursor = connection.cursor(pymysql.cursors.DictCursor)
+        try:
+            result = cursor.execute(sql)
+            logger.info(f"执行SQL: {sql}")
+            connection.commit()
+            logger.info(f"SQL执行结果: {result}")
+            return result
+        except pymysql.MySQLError as e:
+            logger.error(f"Error executing execute: {e}")
+            return None
+        finally:
+            cursor.close()  # 关闭游标
+            connection.close()  # 将连接返回到连接池
+
+    def executemany(self, sql, data):
+        """修改，新增，删除"""
+        connection = self.pool.connection()  # 获取一个连接
+        cursor = connection.cursor(pymysql.cursors.DictCursor)
+        try:
+            cursor.executemany(sql, data)
+            logger.info(f"执行SQL: {sql}")
+            connection.commit()
+            logger.info(f"{cursor.rowcount} records inserted.")
+        except pymysql.MySQLError as e:
+            logger.error(f"Error executing execute: {e}")
+            return None
+        finally:
+            cursor.close()  # 关闭游标
+            connection.close()  # 将连接返回到连接池
+
+    @staticmethod
+    def custom_serializer(obj):
+        if isinstance(obj, datetime):
+            return obj.strftime('%Y-%m-%d %H:%M:%S')  # 转换时间格式
+        elif isinstance(obj, Decimal):
+            return float(obj)  # 转换 Decimal 为 float
+        raise TypeError(f"Type {type(obj)} not serializable")

framework/db/redis_db.py

@@ -0,0 +1,142 @@
+import json
+from redis import Redis
+from redis.exceptions import RedisError
+
+from framework.utils.log_util import logger
+
+
+class RedisDB(Redis):
+
+    def __init__(self, host, port, password, db, max_connections=10):
+        super(RedisDB, self).__init__()
+        self.db = db
+        self.max_connections = max_connections
+        self.conn = Redis(
+            host=host,
+            port=port,
+            password=password,
+            db=self.db,
+            decode_responses=True
+        )
+
+    def __del__(self):
+        try:
+            self.conn.close()
+        except RedisError as e:
+            logger.info(e)
+            raise RedisError(f"redis close error>>>{e}")
+
+    def set_string(self, name, value, ex=None):
+        if ex:
+            res = self.conn.set(name, value, ex)
+            logger.info(f'set {name} {value} {ex} --->{res}')
+        else:
+            res = self.conn.set(name, value)
+            logger.info(f'set {name} {value} --->{res}')
+        if res:
+            return res
+        else:
+            return False
+
+    def set_hash(self, name, value):
+        res = self.conn.hmset(name, value)
+        logger.info(f'hmset {name} {value} --->{res}')
+        if res:
+            return res
+        else:
+            return False
+
+    def set_list(self, name, value):
+        """
+        value可以是字典；列表[字典]；列表[数字]；列表[字符串];空字典;空列表;空字符串；None
+        :param name:
+        :param value:
+        :return:
+        """
+
+        if value:
+            if isinstance(value, dict):
+                self.push(name, value)
+            elif isinstance(value, list):
+                if isinstance(value[0], dict):
+                    value = [json.dumps(item, ensure_ascii=False) for item in value]
+                    self.conn.lpush(name, *value)
+                elif isinstance(value[0], (int, str)):
+                    self.conn.lpush(name, json.dumps(value, ensure_ascii=False))
+                else:
+                    self.conn.lpush(name, str(value))
+            else:
+                self.conn.lpush(name, value)
+        else:
+            self.conn.lpush(name, json.dumps(value))
+
+    def get_string(self, name):
+        res = self.conn.get(name)
+        logger.info(f'get {name}')
+        if res:
+            return res
+        else:
+            return None
+
+    def get_hash(self, name):
+        res = self.conn.hgetall(name)
+        logger.info(f'hgetall {name}')
+        if res:
+            return res
+        else:
+            return None
+
+    def get_list(self, name):
+        res = self.conn.lrange(name, 0, -1)
+        if res:
+            return [json.loads(item) for item in res]
+
+    def get_ttl(self, name):
+        res = self.conn.ttl(name)
+        logger.info(f'ttl {name} ---> {res}')
+        if res:
+            return res
+        else:
+            return None
+
+    def set_ttl(self, name, time):
+        res = self.conn.expire(name, time)
+        logger.info(f'expire {name} {time} ---> {res}')
+        if res:
+            return res
+        else:
+            return False
+
+    def exists(self, name):
+        res = self.conn.exists(name)
+        logger.info(f'exists {name} ---> {res}')
+        if res:
+            return True
+        else:
+            return False
+
+    def delete(self, name):
+        res = self.conn.delete(name)
+        logger.info(f'delete {name} ---> {res}')
+        if res:
+            return True
+        else:
+            return False
+
+    def push(self, name, value):
+        """
+        通过list实现队列，从左侧推消息,消息体只能字典
+        :param name:
+        :param value:
+        :return:
+        """
+        res = self.conn.lpush(name, json.dumps(value, ensure_ascii=False))
+        logger.info(f'lpush {name} ---> {value}')
+        if res:
+            return True
+        else:
+            return False
+
+
+if __name__ == '__main__':
+    redis = RedisDB(db=0)

framework/exit_code.py

@@ -0,0 +1,19 @@
+from enum import Enum
+
+
+class ExitCode(Enum):
+    ENV_NOT_EXIST = 10001  # 测试环境不存在
+    APP_NOT_EXIST = 10002  # 测试系统不存在
+    CONTEXT_YAML_NOT_EXIST = 10003  # 未获取到全局配置文件
+    CONTEXT_YAML_DATA_FORMAT_ERROR = 10004  # 全局配置文件格式不正确
+    CASE_YAML_NOT_EXIST = 10005  # 未获取到对应的YAML测试数据文件
+    CASE_DATA_NOT_EXIST = 10006  # 未获取到用例对应测试数据
+    GLOBAL_ATTRIBUTE_NOT_EXIST = 10007  # 未从CONTEXT中获取到对应变量
+    FUNCTION_NOT_EXIST = 10008  # 未从common.py中或faker对象中获取到对应函数
+    EXTRACT_KEY_NOT_EXIST = 10009  # 未从响应中提取到指定变量
+    LOGIN_ERROR = 10010  # 系统登录失败
+    YAML_MISSING_FIELDS = 10011  # 缺少必填字段
+    MISSING_ASSERTIONS = 10012  # 缺少断言
+    APP_OR_ACCOUNT_NOT_EXIST = 10013  # 账号角色不存在
+    MORE_THAN_ONE_TEST_SUITE_SETUP = 10014  # test_suite_setup标签只能配置一个
+    LOAD_DATABASE_INFO_ERROR = 10015

framework/extract.py

@@ -0,0 +1,101 @@
+import re
+import traceback
+from typing import List
+
+import allure
+import pytest
+from box import Box
+from jsonpath import jsonpath
+
+from framework.utils.common import is_digit
+from framework.utils.log_util import logger
+from framework.exit_code import ExitCode
+from framework.global_attribute import CONTEXT
+
+
+class Extract(object):
+    def __init__(self, response, belong_app):
+        self.response = response
+        self.belong_app = belong_app
+        self.context = CONTEXT
+
+    def extracts(self, expressions: List[dict]):
+        for item in expressions:
+            key = list(item.keys())[0].strip()
+            expression = item.get(key).strip()
+            try:
+                # jsonpath表达式
+                if expression.lower().startswith("$."):
+                    self.extract_by_jsonpath(key, expression)
+                # 正则表达式
+                elif expression.startswith("/") and expression.endswith("/"):
+                    self.extract_by_regex(key, expression[1: -1])
+                # box句点表达式
+                else:
+                    self.extract_by_box(key, expression)
+
+            except Exception as e:
+                with allure.step(f"后置提取变量{key}失败, 失败原因: {e}"):
+                    logger.error(f"后置提取变量{key}失败, 失败原因: {e}")
+                    traceback.print_exc()
+                    pytest.exit(ExitCode.EXTRACT_KEY_NOT_EXIST)
+
+    def extract(self, key, expression):
+        return self.extracts([{key.strip(): expression.strip()}])
+
+    def extract_by_jsonpath(self, key, expression):
+        try:
+            if key.startswith(tuple(f"{app}." for app in self.context.all_app)):
+                self.belong_app, key = key.split(".", 1)
+
+            extract_value = jsonpath(self.response.json(), expression)[0]
+            with allure.step(f"后置提取变量: {key}: {extract_value}"):
+                self.context.set(key, extract_value, self.belong_app)
+                logger.info(f"后置提取变量: {key}: {extract_value}")
+
+        except Exception as e:
+            logger.error(f"jsonpath表达式错误或响应内容异常{e} 表达式: {expression};响应内容: {self.response.json()}")
+            raise Exception(f"jsonpath表达式错误或响应内容异常{e} 表达式: {expression};响应内容: {self.response.json()}")
+
+    def extract_by_regex(self, key, reg_expression):
+        try:
+            if key.startswith(tuple(f"{app}." for app in self.context.all_app)):
+                self.belong_app, key = key.split(".", 1)
+            extract_value = re.search(reg_expression, self.response.text, flags=re.S).group()
+            with allure.step(f"后置提取变量: {key}: {extract_value}"):
+                if is_digit(extract_value):
+                    self.context.set(key, eval(extract_value), self.belong_app)
+                else:
+                    self.context.set(key, extract_value, self.belong_app)
+                logger.info(f"后置提取变量: {key}: {extract_value}")
+
+        except Exception:
+            logger.error(f"正则表达式或响应内容异常。表达式: {reg_expression}; 响应内容: {self.response.text}")
+            raise Exception(f"正则表达式或响应内容异常。表达式: {reg_expression}; 响应内容: {self.response.text}")
+
+    def extract_by_box(self, key, expression):
+        if key.startswith(tuple(f"{app}." for app in self.context.all_app)):
+            self.belong_app, key = key.split(".", 1)
+        extract_value = self.get_nested_value(Box(self.response.json()), expression)
+        if not extract_value:
+            logger.error(f"box表达式或响应内容异常 表达式: {expression}; 响应内容: {self.response.json()}")
+            raise Exception(f"box表达式或响应内容异常 表达式: {expression}; 响应内容: {self.response.json()}")
+        else:
+            with allure.step(f"后置提取变量: {key}: {extract_value}"):
+                self.context.set(key, extract_value, self.belong_app)
+                logger.info(f"后置提取变量: {key}: {extract_value}")
+
+    @staticmethod
+    def get_nested_value(obj, attr_path):
+        """通过字符串路径（如 'a.b[0].c'）获取嵌套属性值"""
+        # 使用正则表达式分解路径，支持属性和索引的组合
+        path_elements = re.findall(r'(\w+)|\[(\d+)]', attr_path)
+        try:
+            for attr, index in path_elements:
+                if attr:  # 属性部分
+                    obj = getattr(obj, attr)
+                if index:  # 索引部分
+                    obj = obj[int(index)]
+            return obj
+        except Exception:
+            return None

framework/global_attribute.py

@@ -0,0 +1,100 @@
+import os
+import traceback
+
+import pytest
+from box import Box
+from box.exceptions import BoxError
+
+from framework.utils.log_util import logger
+from framework.utils.common import singleton
+from config.settings import ROOT_DIR
+from framework.exit_code import ExitCode
+
+
+class GlobalAttribute(object):
+    def __setattr__(self, key, value):
+        super().__setattr__(
+            key,
+            Box(value) if isinstance(value, dict) else self.list2box(value) if isinstance(value, list) else value
+        )
+
+    def __str__(self):
+        return Box(self.__dict__).to_json(indent=2)
+
+    def get(self, key, app=None):
+        if app:
+            obj = getattr(self, app, None)
+        else:
+            obj = self
+        value = getattr(obj, key, None)
+        return Box(value) if isinstance(value, dict) else self.list2box(value) if isinstance(value, list) else value
+
+    def set(self, key, value, app=None):
+        if app:
+            key = f"{app}.{key}"
+            self.set_by_chain(key, value)
+        else:
+            setattr(self, key, value)
+
+    def set_by_chain(self, key_chain, value):
+        """
+        链式格式的key进行set
+        :param key_chain:
+        :param value:
+        :return:
+        """
+        keys = key_chain.split(".")
+        for key in keys[:-1]:
+            if not hasattr(self, key):
+                setattr(self, key, Box())  # 创建一个空对象属性
+            self = getattr(self, key)
+        setattr(self, keys[-1], value)
+
+    def set_from_dict(self, dic, app=None):
+        for k, v in dic.items():
+            self.set(k, v, app)
+
+    def init_test_case_data_dict(self):
+        new_dict = dict()
+        new_dict['test_case_datas'] = dict()
+        for k, v in new_dict.items():
+            self.set(k, v)
+
+    def set_from_yaml(self, filename, env, app=None):
+        try:
+            file = os.path.join(ROOT_DIR, filename)
+            if not os.path.exists(file):
+                logger.error(f"{file}文件不存在")
+                pytest.exit(ExitCode.CONTEXT_YAML_NOT_EXIST)
+            self.set_from_dict(dict(Box().from_yaml(filename=file).get(env)), app)
+        except BoxError as e:
+            logger.error(f"{file}文件内容不是字典类型:{e}")
+            traceback.print_exc()
+            pytest.exit(ExitCode.CONTEXT_YAML_DATA_FORMAT_ERROR)
+
+    def delete(self, key):
+        delattr(self, key)
+
+    def list2box(self, array: list):
+        for index, item in enumerate(array):
+            if isinstance(item, dict):
+                array[index] = Box(item)
+            elif isinstance(item, list):
+                array[index] = self.list2box(item)
+        return array
+
+
+@singleton
+class Context(GlobalAttribute):
+    ...
+
+
+@singleton
+class Config(GlobalAttribute):
+    ...
+
+
+# 创建管理变量的全局对象，用于存储临时变量
+CONTEXT = Context()
+# 创建配置内容管理的全局对象
+CONFIG = Config()

framework/http_client.py

@@ -0,0 +1,163 @@
+import re
+from typing import List
+from urllib.parse import urljoin
+
+import allure
+import requests
+from box import Box
+import json as built_json
+from jsonpath import jsonpath as jp
+from requests.models import Response
+from framework.extract import Extract
+from framework.utils.log_util import logger
+from framework.global_attribute import CONTEXT
+from requests_toolbelt import MultipartEncoder
+
+
+class ResponseUtil(object):
+    def __init__(self, response: Response):
+        self.response = response
+        self.box = Box(response.json())
+
+    def __getattr__(self, name):
+        try:
+            return getattr(self.box, name)
+        except AttributeError:
+            return getattr(self.response, name)
+
+    def __str__(self):
+        return self.text
+
+    def jsonpath(self, expr, headers=False):
+        """
+        使用jsonpath语法从响应体中提取内容
+        @param expr: jsonpath语法
+        @param headers: 从响应头中提取内容
+        @return:
+        """
+        result = jp(dict(self.response.headers), expr) if headers else jp(self.json(), expr)
+        if result is False:
+            return ""
+        if len(result) == 1:
+            return result[0]
+        return result
+
+    @property
+    def jsonp(self):
+        """返回json"""
+        jsonp_re = re.compile(r".*?\((?P<text>.*)\)")
+        return built_json.loads(jsonp_re.match(self.response.text).group("text"))
+
+    def json(self):
+        return self.response.json()
+
+    def extract(self, app, key, expression):
+        """
+        进行变量提取
+        :param app:
+        :param key: 保存变量的名称
+        :param expression: 提取变量表达式
+        :return:
+        """
+        Extract(self.response, app).extract(key, expression)
+
+    def extracts(self, app, expressions: List[dict]):
+        """
+        进行变量提取
+        :param app:
+        :param expressions: 提取变量表达式
+        :return:
+        """
+        Extract(self.response, app).extracts(expressions)
+
+
+class HttpClient(object):
+
+    def __init__(self, headers=None):
+        """
+
+        @param headers: 请求头
+        @param cookies: cookies
+        """
+
+        self.headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36",
+            "Content-Type": "application/json"
+        }
+        self.headers.update(headers or {})
+        self.response = None
+
+    def __send_request(self, data):
+        _is_multipart = data.get("_is_multipart")
+        request_obj = data.get("request")
+        with allure.step("发送请求"):
+            if _is_multipart:
+                m = MultipartEncoder(fields=request_obj["data"])
+                request_obj["data"] = m
+                request_obj["headers"] = {'Content-Type': m.content_type}
+            else:
+                request_obj["headers"].update(self.headers)
+            self.response = ResponseUtil(requests.request(**request_obj))
+
+            with allure.step(f"请求url: {request_obj.get('url')}"):
+                logger.info(f"请求url: {request_obj.get('url')}")
+            with allure.step(f"请求method: {request_obj.get('method')}"):
+                logger.info(f"请求method: {request_obj.get('method')}")
+            with allure.step(f"请求headers: {request_obj.get('headers')}"):
+                logger.info(f"请求headers: {request_obj.get('headers')}")
+            if request_obj.get('request'):
+                with allure.step(f"请求参数params: {request_obj.get('params')}"):
+                    logger.info(f"请求参数params: {request_obj.get('params')}")
+            if request_obj.get('data'):
+                with allure.step(f"请求参数data: {request_obj.get('data')}"):
+                    logger.info(f"请求参数data: {request_obj.get('data')}")
+            if request_obj.get('json'):
+                with allure.step(f"请求参数json: {request_obj.get('json')}"):
+                    logger.info(f"请求参数json: {request_obj.get('json')}")
+
+        with allure.step("响应结果"):
+            with allure.step(f"响应状态码: {self.response.status_code}"):
+                logger.info(f"响应状态码: {self.response.status_code}")
+            with allure.step(f"响应headers: {self.response.headers}"):
+                logger.info(f"响应headers: {self.response.headers}")
+            with allure.step(f"响应body: {self.response.json()}"):
+                logger.info(f"响应body: {self.response.json()}")
+
+        # # 断言
+        # validates = params.get("validate")
+        # if validates:
+        #     with allure.step("结果断言"):
+        #         Validate(self.response).valid(validates)
+
+        # 提取变量
+        expressions = data.get("extract")
+        belong_app = data.get("_belong_app")
+        if expressions:
+            with allure.step("提取变量"):
+                Extract(self.response, belong_app).extracts(expressions)
+
+        return self.response
+
+    def request(self, data, **kwargs):
+        if data:
+            return self.__send_request(data)
+
+        return ResponseUtil(requests.request(headers=self.headers, **kwargs))
+
+    def post(self, app, url, data=None, json=None, **kwargs):
+        return self.request(method="post", url=urljoin(CONTEXT.get(app=app, key="domain"), url), data=data,
+                            json=json, **kwargs)
+
+    def get(self, app, url, params=None, **kwargs):
+        return self.request(method="get", url=urljoin(CONTEXT.get(app=app, key="domain"), url), params=params,
+                            **kwargs)
+
+    def put(self, app, url, data=None, **kwargs):
+        return self.request(method="put", url=urljoin(CONTEXT.get(app=app, key="domain"), url), data=data,
+                            **kwargs)
+
+    def delete(self, app, url, **kwargs):
+        return self.request(method="delete", url=urljoin(CONTEXT.get(app=app, key="domain"), url), **kwargs)
+
+    def update_headers(self, headers):
+        self.headers.update(headers)