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

framework/render_data.py

@@ -0,0 +1,185 @@
+import os
+import re
+import importlib
+import traceback
+
+import allure
+import pytest
+from faker import Faker
+from framework.utils.log_util import logger
+from framework.exit_code import ExitCode
+from framework.global_attribute import CONTEXT
+from config.settings import FAKER_LANGUAGE, DATA_DIR
+
+
+class SingletonFaker(object):
+    instance = None
+    init_flag = False
+
+    def __init__(self, locale):
+        if self.init_flag:
+            return
+        self.faker = Faker(locale)
+
+    def __new__(cls, *args, **kwargs):
+        if cls.instance is None:
+            cls.instance = super().__new__(cls)
+        return cls.instance
+
+
+class RenderData(object):
+    def __init__(self, data):
+        self.data = data
+        self.request = data.get("request")
+        self.context = CONTEXT
+        self.faker = SingletonFaker(locale=FAKER_LANGUAGE).faker
+        self._is_multipart = False
+
+    def render(self):
+        """
+        占位符赋值
+        :return:
+        """
+        with allure.step("渲染数据"):
+            self.replace_attribute(self.request)
+        self.data["request"] = self.request
+        self.data["_is_multipart"] = self._is_multipart
+        return self.data
+
+    def replace_attribute(self, data):
+        pattern = re.compile(r"\$\{([\w.\[\]0-9]+(?:\(\w*(?:,\w*)*\))?)}")
+        file_path_pattern = re.compile(
+            r'^(?:[^/\\]+\\)*[^/\\]+\.(txt|doc|docx|pdf|xls|xlsx|ppt|pptx|md|jpg|jpeg|png|gif|svg|webp|ico|mp4|avi|mov|wmv|flv|mkv|webm|mp3)$')
+
+        # 如果数据是字典类型，则遍历其键值对
+        if isinstance(data, dict):
+            for key, value in data.items():
+                # 递归遍历嵌套的字典或列表
+                if isinstance(value, (dict, list)):
+                    self.replace_attribute(value)
+                # 如果是字符串类型并匹配正则表达式，则替换
+                elif isinstance(value, str):
+                    if pattern.search(value):
+                        data[key] = self.get_attribute(value[2:-1])
+                    elif file_path_pattern.search(value):
+                        data[key] = self.open_file_for_multipart(value)
+                        self._is_multipart = True
+
+        # 如果数据是列表类型，则遍历其元素
+        elif isinstance(data, list):
+            for index, item in enumerate(data):
+                # 递归遍历嵌套的字典或列表
+                if isinstance(item, (dict, list)):
+                    self.replace_attribute(item)
+                # 如果是字符串类型并匹配正则表达式，则替换
+                elif isinstance(item, str):
+                    if pattern.search(item):
+                        data[index] = self.get_attribute(item[2:-1])
+                    elif file_path_pattern.search(item):
+                        data[index] = self.open_file_for_multipart(item)
+                        self._is_multipart = True
+
+    def get_attribute(self, keyword):
+        if not keyword.endswith(")"):
+            return self.get_attribute_variable(keyword)
+        # 如果关键字是函数
+        else:
+            pattern = re.compile(r'(?P<func_name>.+)\((?P<args>.*)\)')
+            match = re.match(pattern, keyword)
+            # 匹配方法名
+            func_name = match.group("func_name")
+            # 匹配方法位置参数
+            args = match.group("args")
+            if args:
+                # 将参数中字符串类型的数字转成数字类型
+                args = [eval(i) for i in args.replace(",", "").split(",")]
+                return self.get_func_variable(keyword, func_name, *args)
+            else:
+                return self.get_func_variable(keyword, func_name)
+
+    def get_attribute_variable(self, expression):
+        """
+        去全局上下文中获取value并进行替换
+        :param expression:
+        :return:
+        """
+        if not expression.startswith(tuple(f"{app}." for app in self.context.all_app)):
+            belong_app = self.data.get('_belong_app')
+            new_expression = f"{belong_app}.{expression}"
+        else:
+            new_expression = expression
+        value = self.get_nested_value(self.context, expression) or self.get_nested_value(self.context, new_expression)
+
+        if not value:
+            logger.warning(f"未从CONTEXT中获取到对应变量{expression}")
+            # pytest.exit(ExitCode.GLOBAL_ATTRIBUTE_NOT_EXIST)
+
+            return None
+        with allure.step(f"{expression}: {value}"):
+            logger.info(f"前置读取变量: {expression}: {value}")
+            return value
+
+    def get_func_variable(self, keyword, func_name, *args):
+        """
+        去utils>common.py中或faker对象中执行对应的方法并进行替换
+        :param keyword:
+        :param func_name:
+        :param args:
+        :return:
+        """
+        module = importlib.import_module("common")
+        try:
+            value = getattr(module, func_name)(*args)
+        except AttributeError:
+            value = getattr(self.faker, func_name, None)(*args)
+
+        if not value:
+            logger.error(f"common.py文件或faker对象中不存在函数:{keyword}")
+            traceback.print_exc()
+            pytest.exit(ExitCode.FUNCTION_NOT_EXIST)
+        else:
+            with allure.step(f"{keyword}: {value}"):
+                logger.info(f"前置读取函数: {keyword}: {value}")
+                return value
+
+    def get_file_obj(self, data, pattern):
+        # 如果 data 是字典，则遍历每一个键值对
+        if isinstance(data, dict):
+            for key, value in data.items():
+                # 递归调用处理值
+                data[key] = self.get_file_obj(value, pattern)
+
+        # 如果 data 是列表，则遍历每一个元素
+        elif isinstance(data, list):
+            for index in range(len(data)):
+                # 递归调用处理列表中的每一个元素
+                data[index] = self.get_file_obj(data[index], pattern)
+
+        # 如果 data 是字符串，则检查是否匹配正则表达式
+        elif isinstance(data, str):
+            if re.fullmatch(pattern, data):
+                # 如果匹配，则替换为文件流
+                self._is_multipart = True
+                return self.open_file_for_multipart(data)
+        # 返回处理后的数据
+        return data
+
+    @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
+
+    @staticmethod
+    def open_file_for_multipart(filepath):
+        f = open(os.path.join(DATA_DIR, "file", filepath), "rb")
+        return os.path.basename(f.name), f, "application/octet-stream"

framework/report.py

@@ -0,0 +1,102 @@
+import json
+import argparse
+from pathlib import Path
+import datetime
+import traceback
+from framework.db.mysql_db import MysqlDB
+from config.settings import DATABASE_HOST, DATABASE_PASSWORD, DATABASE_DB, DATABASE_USERNAME, DATABASE_PORT
+
+
+def timestamp_to_datetime_str(timestamp):
+    # 将时间戳转换为 datetime 对象
+    dt = datetime.datetime.fromtimestamp(timestamp)
+    # 将 datetime 对象格式化为指定格式的字符串
+    return dt.strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
+
+
+if __name__ == '__main__':
+    print('调用report脚本')
+    # 创建 ArgumentParser 对象
+    parser = argparse.ArgumentParser(description="演示如何使用 argparse 获取命令行参数")
+    # 添加位置参数
+    parser.add_argument('--task', help="输入任务的名字", required=True)
+    # 添加可选参数
+    parser.add_argument('--buildnum', type=int, help="输入构建次数", required=True)
+    parser.add_argument('--allure_result', type=str, help="allure_result路径", required=True)
+
+    # 解析命令行参数
+    args = parser.parse_args()
+    if not args.task:
+        exit(400)
+    print(f"task, {args.task}!")
+    taskName = args.task
+
+    if not args.buildnum:
+        exit(400)
+    print(f"buildnum, {args.buildnum}!")
+    buildNum = args.buildnum
+
+    if not args.allure_result:
+        exit(400)
+    print(f"allure_result_path, {args.allure_result}!")
+    allure_result_path = args.allure_result
+
+    # 初始化数据库连接
+    print('初始化数据库连接')
+    mysqlDB = MysqlDB(
+        host=DATABASE_HOST,
+        username=DATABASE_USERNAME,
+        password=DATABASE_PASSWORD,
+        port=DATABASE_PORT,
+        db=DATABASE_DB
+    )
+
+    current_time = datetime.datetime.now()
+    formatted_time = current_time.strftime('%Y-%m-%d %H:%M:%S')
+    task_id = mysqlDB.insert(
+        f"INSERT INTO tbl_task (name,last_run_time,buildnum) VALUES ('{taskName}','{formatted_time}','{buildNum}')")
+    print(f'{task_id}')
+
+    # 获取所有‘result.json‘结尾的文件
+    print('获取所有‘*result.json‘结尾的文件')
+    folder = Path(allure_result_path)
+    all = list(folder.rglob('*result.json'))
+    print(f'files count: {len(all)}')
+
+    for file_path in all:
+        try:
+            # 打开 JSON 文件
+            with open(file_path, 'r', encoding='utf-8') as file:
+                # 解析 JSON 文件内容
+                data = json.load(file)
+                # 示例：访问解析后的数据
+                if 'fullName' in data:
+                    print(f"fullName: {data['fullName']}")
+                if 'testCaseId' in data:
+                    print(f"testCaseId: {data['testCaseId']}")
+                if 'start' in data:
+                    print(f"start: {data['start']}")
+                if 'stop' in data:
+                    print(f"stop: {data['stop']}")
+                if 'uuid' in data:
+                    print(f"uuid: {data['uuid']}")
+                if 'status' in data:
+                    print(f"status: {data['status']}")
+
+                if 'name' in data:
+                    print(f"name: {data['name']}")
+
+                    if 'statusDetails' in data and data['statusDetails'] is not None:
+                        mysqlDB.execute(
+                            f"INSERT INTO tbl_test_case (test_case_id,status,name,starttime,stoptime,uuid,task_id,message) VALUES ('{data['testCaseId']}','{data['status']}','{data['name']}',{data['start']},{data['stop']},'{data['uuid']}',{task_id},'{str(data['statusDetails'])}')")
+                    else:
+                        mysqlDB.execute(
+                            f"INSERT INTO tbl_test_case (test_case_id,status,name,starttime,stoptime,uuid,task_id) VALUES ('{data['testCaseId']}','{data['status']}','{data['name']}',{data['start']},{data['stop']},'{data['uuid']}',{task_id})")
+
+        except FileNotFoundError:
+            print("错误: 文件未找到，请检查文件路径是否正确。")
+        except json.JSONDecodeError:
+            print("错误: JSON 解析出错，请检查文件内容格式是否正确。")
+        except Exception as e:
+            print(f"发生未知错误: {e}")
+            traceback.print_exc()

framework/startapp.py

@@ -0,0 +1,126 @@
+import os
+import argparse
+from pathlib import Path
+
+import yaml
+from framework.utils.common import snake_to_pascal
+from config.settings import CONFIG_DIR, CASES_DIR, DATA_DIR
+
+
+def create_yaml(app):
+    """生成 YAML 文件"""
+    os.makedirs(os.path.join(CONFIG_DIR, app), exist_ok=True)
+    with open(os.path.join(CONFIG_DIR, app, "context.yaml"), 'w', encoding="utf-8") as f:
+        yaml.dump({
+            "dev": {
+                "domain": "dev.example.com",
+                "accounts": {
+                    "admin": {
+                        "username": "admin",
+                        "password": "test"
+                    }
+                }
+            }
+        }, f, default_flow_style=False, allow_unicode=True, sort_keys=False)
+    with open(os.path.join(CONFIG_DIR, app, "config.yaml"), 'w', encoding="utf-8") as f:
+        yaml.dump({
+            "dev": {
+                "mysql": {
+                    "host": None,
+                    "username": None,
+                    "password": None,
+                    "port": 3306
+                },
+                "redis": {
+                    "host": None,
+                    "password": None,
+                    "port": 6379
+                }
+            }
+        }, f, default_flow_style=False, allow_unicode=True, sort_keys=False)
+
+
+def create_test_case(app: str):
+    os.makedirs(os.path.join(CASES_DIR, app), exist_ok=True)
+    file_path = Path(os.path.join(CASES_DIR, app, "../__init__.py"))
+    file_path.touch(exist_ok=True)
+    content = f"""
+from test_case import BaseTestCase
+
+
+class TestUntitled(BaseTestCase):
+
+    def test_untitled(self):
+        # 发送请求
+        self.request(app="{app}", account="user", data=self.data)
+        # 断言
+        assert self.response.status_code == 200
+        assert len(self.response.jsonpath("$.data.balances")) > 0"""
+    with open(os.path.join(CASES_DIR, app, "test_untitled.py"), 'w', encoding="utf-8") as file:
+        file.write(content)
+
+
+def create_test_data(app):
+    os.makedirs(os.path.join(DATA_DIR, app), exist_ok=True)
+
+    with open(os.path.join(DATA_DIR, app, "test_untitled.yaml"), 'w', encoding="utf-8") as f:
+        yaml.dump({
+            "case_common": {
+                "module": "功能模块名称",
+                "describe": "测试场景描述"
+            },
+            "test_untitled": {
+                "title": "登录成功",
+                "level": "p0",
+                "request": {
+                    "url": "/login",
+                    "method": "post",
+                    "json": {
+                        "name": "Jerry"
+                    }
+                },
+                "extract": [
+                    {
+                        "id": "$.data.token"
+                    }
+                ]
+            }
+        }, f, default_flow_style=False, allow_unicode=True, sort_keys=False)
+
+
+def create_app_session(app):
+    content = f"""
+
+class {snake_to_pascal(app)}Login(Login):
+
+    def login(self, username, password, secret_key):
+        client = HttpClient()
+        # TODO 需要实现登录逻辑，将登录获取到的token添加到headers中
+        token = None
+        client.update_headers({{"token": token}})
+        return client"""
+    with open(os.path.join(CASES_DIR, "conftest.py"), "a", encoding="utf-8") as f:
+        f.write(content)
+
+
+def process_command_line_args():
+    parser = argparse.ArgumentParser(description='startapp')
+    parser.add_argument('app', type=str, help='创建应用')
+    return parser.parse_args()
+
+
+def main():
+    args = process_command_line_args()
+    app = args.app
+    if not os.path.exists(os.path.join(DATA_DIR, app)):
+        create_yaml(app)
+        create_test_case(app)
+        create_test_data(app)
+        create_app_session(app)
+        print(f"app {app}创建成功")
+    else:
+        print(f"app {app}已存在,未执行创建")
+
+
+if __name__ == '__main__':
+    main()

framework/utils/common.py

@@ -0,0 +1,211 @@
+import re
+import os
+import time
+import binascii
+from datetime import datetime
+from urllib.parse import unquote, quote, quote_plus, unquote_plus
+import pyotp
+import cn2an as c2a
+
+from config.settings import CONFIG_DIR
+
+
+def generate_2fa_code(secret_key):
+    """
+    获取2fa code
+    :return:
+    """
+    current_time = int(time.time())
+    totp = pyotp.TOTP(secret_key)
+    google_code = totp.at(current_time)
+
+    return google_code
+
+
+def is_digit(string):
+    """判断是否为数字字符串"""
+    digit_re = re.compile(r'^-?[0-9.]+$')
+    return digit_re.search(string)
+
+
+def an2cn(integer):
+    """阿拉伯数字转中文数字"""
+    return c2a.an2cn(integer)
+
+
+def cn2an(string):
+    """中文数字转阿拉伯数字"""
+    return c2a.cn2an(string)
+
+
+def clean_symbol(text):
+    """
+    清除字符串特殊符号
+    :param text:
+    :return:
+    """
+    return re.sub('[’!"#$`%&\'：|*+～·,-./:;<=「」>@，。?★、…—？“”‘！[\\]^_{}~]+', "", text)
+
+
+def get_long_timestamp(int_type=False):
+    """
+    获取毫秒级时间戳
+    :param int_type: 默认返回str类型
+    :return:
+    """
+
+    if int_type:
+        return int(time.time() * 1000)
+    return str(int(time.time() * 1000))
+
+
+def get_short_timestamp(int_type=False):
+    """
+    获取秒级时间戳
+    :param int_type: 默认返回str类型
+    :return:
+    """
+    if int_type:
+        return int(time.time())
+    return str(int(time.time()))
+
+
+def get_current_datetime():
+    """
+    获取当前日期和时间 2023-02-19 08:31:51
+    :return:
+    """
+    return time.strftime("%Y-%m-%d %X")
+
+
+def get_current_date():
+    """
+    获取当前日期 2023-02-19
+    :return:
+    """
+    return time.strftime("%Y-%m-%d")
+
+
+def timestamp2datetime(timestamp):
+    """
+    时间戳转日期时间
+    @param timestamp:
+    @return:
+    """
+    if isinstance(timestamp, int):
+        timestamp = str(timestamp)
+    timestamp = timestamp[:10]
+    return datetime.fromtimestamp(int(timestamp))
+
+
+def timestamp2date(timestamp):
+    """
+    时间戳转日期
+    @param timestamp:
+    @return:
+    """
+    if isinstance(timestamp, int):
+        timestamp = str(timestamp)
+    timestamp = timestamp[:10]
+    return time.strftime("%Y-%m-%d", time.localtime(int(timestamp)))
+
+
+def valid_hex_format(s):
+    """
+    判断是否为16进制字符串
+    :param s:
+    :return:
+    """
+    hex_re = re.compile(r"^[0-9a-fA-F]+$")
+    if hex_re.match(s):
+        return True
+    return False
+
+
+def valid_b64_format(s):
+    """
+    判断是否为base64字符串
+    :param s:
+    :return:
+    """
+    b64_re = re.compile(r"^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$")
+    if b64_re.match(s):
+        return True
+    return False
+
+
+def hex_to_bytes(hex_str):
+    """
+    16进制->字节
+    :param hex_str:
+    :return:
+    """
+    return binascii.a2b_hex(hex_str).strip()
+
+
+def bytes_to_hex(byte):
+    """
+    字节->16进制
+    :param byte:
+    :return:
+    """
+    return binascii.b2a_hex(byte)
+
+
+def url_encode(string, use_quote_plus=False, encoding="utf-8"):
+    """
+    url编码
+    :param string:
+    :param use_quote_plus: 是否使用quote_plus编码
+    :param encoding: 编码格式
+    :return:
+    """
+    if use_quote_plus:
+        return quote_plus(string, encoding=encoding)
+    return quote(string, encoding=encoding)
+
+
+def url_decode(string, use_unquote_plus=False, encoding="utf-8"):
+    """
+    url解码
+    :param string:
+    :param use_unquote_plus: 是否使用unquote_plus解码
+    :param encoding: 编码格式
+    :return:
+    """
+    if use_unquote_plus:
+        return unquote_plus(string, encoding=encoding)
+    return unquote(string, encoding=encoding)
+
+
+def singleton(cls):
+    """
+    单例模式装饰器
+    :param cls:
+    :return:
+    """
+    instances = {}
+
+    def get_instance(*args, **kwargs):
+        if cls not in instances:
+            instances[cls] = cls(*args, **kwargs)
+        return instances[cls]
+
+    return get_instance
+
+
+def snake_to_pascal(name: str) -> str:
+    # 将字符串按照下划线分割，然后将每个单词的首字母大写，最后连接起来
+    return ''.join(word.capitalize() for word in name.split('_'))
+
+
+def get_apps():
+    """
+    获取所有app
+    """
+    return [name for name in os.listdir(CONFIG_DIR) if
+            os.path.isdir(os.path.join(CONFIG_DIR, name)) and not name.startswith(("__", "."))]
+
+
+if __name__ == '__main__':
+    print(get_apps())