iflow-mcp_galaxyxieyu_api-auto-test 0.1.0__py3-none-any.whl

atf/conftest.py

@@ -0,0 +1,65 @@
+# @time:    2024-09-10
+# @author:  xiaoqq
+
+import time
+from datetime import datetime
+from atf.core.globals import Globals
+import pytest
+
+
+# ==================== pytest-html 报告配置 ====================
+
+def pytest_configure(config):
+    """配置 pytest-html 元数据"""
+    config._metadata = getattr(config, '_metadata', {}) or {}
+    config._metadata["项目"] = "API Auto Test Framework"
+    config._metadata["框架"] = "pytest + pytest-html"
+
+
+def pytest_html_report_title(report):
+    """设置报告标题"""
+    report.title = "API 自动化测试报告"
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_runtest_makereport(item, call):
+    """为测试结果添加描述信息"""
+    outcome = yield
+    report = outcome.get_result()
+    report.description = str(item.function.__doc__ or "")
+
+
+# ==================== 测试结果收集 ====================
+
+def pytest_terminal_summary(terminalreporter, exitstatus, config):
+    """
+    获取用例执行结果，保存到全局变量
+    """
+    total = terminalreporter._numcollected
+    passed = len([i for i in terminalreporter.stats.get("passed", []) if i.when != "teardown"])
+    failed = len([i for i in terminalreporter.stats.get("failed", []) if i.when != "teardown"])
+    error = len([i for i in terminalreporter.stats.get("error", []) if i.when != "teardown"])
+    skipped = len([i for i in terminalreporter.stats.get("skipped", []) if i.when != "teardown"])
+    _start_time = terminalreporter._sessionstarttime
+    start_time = datetime.utcfromtimestamp(_start_time).strftime("%Y-%m-%d %H:%M:%S")
+    duration = time.time() - _start_time
+
+    conclusion = "执行通过"
+    if failed and error:
+        conclusion = "执行失败，包含失败用例和错误用例！"
+    elif failed and not error:
+        conclusion = "执行失败，包含失败用例！"
+    elif not failed and error:
+        conclusion = "执行失败，包含报错用例！"
+
+    results = {
+        "conclusion": conclusion,
+        "total": total,
+        "passed": passed,
+        "failed": failed,
+        "error": error,
+        "skipped": skipped,
+        "start_time": start_time,
+        "duration": duration
+    }
+    Globals.set('test_results', results)

atf/core/__init__.py

@@ -0,0 +1,40 @@
+"""核心模块
+
+使用延迟导入，避免在导入 atf.core 包时加载所有依赖。
+"""
+
+from importlib import import_module
+
+__all__ = [
+    "Globals",
+    "ConfigManager",
+    "LogManager",
+    "RequestHandler",
+    "VariableResolver",
+    "AssertHandler",
+    "LoginHandler",
+]
+
+_LAZY_IMPORTS = {
+    "Globals": "atf.core.globals",
+    "ConfigManager": "atf.core.config_manager",
+    "LogManager": "atf.core.log_manager",
+    "RequestHandler": "atf.core.request_handler",
+    "VariableResolver": "atf.core.variable_resolver",
+    "AssertHandler": "atf.core.assert_handler",
+    "LoginHandler": "atf.core.login_handler",
+}
+
+
+def __getattr__(name):
+    module_path = _LAZY_IMPORTS.get(name)
+    if not module_path:
+        raise AttributeError(f"module 'atf.core' has no attribute '{name}'")
+    module = import_module(module_path)
+    value = getattr(module, name)
+    globals()[name] = value
+    return value
+
+
+def __dir__():
+    return sorted(list(globals().keys()) + list(_LAZY_IMPORTS.keys()))

atf/core/assert_handler.py

@@ -0,0 +1,336 @@
+# @time:    2024-08-06
+# @author:  xiaoqq
+
+import re
+import mysql.connector
+import threading
+from atf.core.log_manager import log
+
+class AssertHandler:
+    """断言处理器"""
+    def __init__(self):
+        self.connection = None
+        self.lock = threading.Lock()
+    
+    def __enter__(self):
+        log.info("Opening database connection")
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.connection:
+            log.info("Closing database connection")
+            self.connection.close()
+
+    def handle_assertion(self, asserts, response, db_config=None):
+        """
+        验证 assert 列表中的所有断言
+        :param asserts: 断言列表
+        :param response: 请求返回的 response 对象
+        :param db_config: 数据库配置字典，包含 host, user, password, database 等信息
+        """
+        log.info(f"执行断言: {asserts}")
+        # 如果存在 MySQL 相关的断言类型，建立数据库连接
+        if any(assertion['type'].startswith('mysql') for assertion in asserts):
+            if db_config is None:
+                raise ValueError("数据库配置 db_config 不能为空，因为有 MySQL 相关断言")
+            self.connection = mysql.connector.connect(**db_config)
+        
+        for assertion in asserts:
+            assert_type = assertion.get('type')
+            field_path = assertion.get('field')
+            expected = assertion.get('expected')
+            container = assertion.get('container')
+            query = assertion.get('query')
+
+            # 检查必填字段
+            if not field_path and assert_type not in [
+                'mysql_query',
+                'mysql_query_exists',
+                'mysql_query_true',
+                'contains',
+                'contain',
+                'status_code',
+                'status',
+            ]:
+                log.error(f"断言的 'field' 不能为空: {assertion}")
+                raise ValueError(f"断言的 'field' 不能为空: {assertion}")
+            if assert_type in ['equal', 'equals', 'not equal', 'not_equal', 'not_equals'] and expected is None:
+                log.error(f"断言的 'expected' 不能为空: {assertion}")
+                raise ValueError(f"断言的 'expected' 不能为空: {assertion}")
+            if assert_type == 'length' and expected is None:
+                log.error(f"断言的 'expected' 不能为空: {assertion}")
+                raise ValueError(f"断言的 'expected' 不能为空: {assertion}")
+            if assert_type in ['in', 'not in', 'not_in'] and container is None:
+                log.error(f"断言的 'container' 不能为空: {assertion}")
+                raise ValueError(f"断言的 'container' 不能为空: {assertion}")
+
+            # 获取字段的实际值
+            field_value = self.get_field_value(response, field_path) if field_path else None
+
+            # 处理各种断言类型
+            if assert_type in ('status_code', 'status'):
+                # status_code 检查 HTTP 状态码（response 可能是 dict 或 Response 对象）
+                actual_status = response.get('_status_code') if isinstance(response, dict) else response.status_code
+                assert actual_status == expected, f"Expected status code {expected}, but got {actual_status}"
+            elif assert_type in ('equal', 'equals'):
+                assert field_value == expected, f"Expected {expected}, but got {field_value}"
+            elif assert_type in ('not equal', 'not_equal', 'not_equals'):
+                assert field_value != expected, f"Expected not {expected}, but got {field_value}"
+            elif assert_type in ('exists', 'exist'):
+                assert field_value is not None, f"Expected field {field_path} to exist, but got None"
+            elif assert_type in ('is_none', 'is None', 'None'):
+                assert field_value is None, f"Expected None, but got {field_value}"
+            elif assert_type in ('is_not_none', 'is not None', 'not None'):
+                assert field_value is not None, f"Expected not None, but got {field_value}"
+            elif assert_type == 'length':
+                assert field_value is not None, f"Expected field {field_path} not to be None for length assertion"
+                try:
+                    actual_len = len(field_value)
+                except TypeError:
+                    raise ValueError(f"length 断言不支持该类型: field={field_path}, value={field_value}")
+                assert actual_len == expected, f"Expected length {expected}, but got {actual_len}"
+            elif assert_type == 'in':
+                assert field_value in container, f"Expected {field_value} to be in {container}"
+            elif assert_type in ('not in', 'not_in'):
+                assert field_value not in container, f"Expected {field_value} to be not in {container}"
+            elif assert_type in ('contains', 'contain'):
+                # contains 不需要 field，直接检查 response 中是否包含 expected
+                def _check_contains(obj, target):
+                    """递归检查 obj 中是否包含 target"""
+                    if isinstance(obj, dict):
+                        return any(_check_contains(v, target) for v in obj.values())
+                    elif isinstance(obj, list):
+                        return any(_check_contains(item, target) for item in obj)
+                    elif isinstance(obj, str):
+                        return target in obj
+                    else:
+                        return str(obj) == str(target)
+
+                assert _check_contains(response, expected), f"Expected {expected} to be in {response}"
+            elif assert_type == 'mysql_query':
+                self._validate_mysql_query(query, expected)
+            elif assert_type == 'mysql_query_exists':
+                self._validate_mysql_query_exists(query)
+            elif assert_type == 'mysql_query_true':
+                self._validate_mysql_query_true(query)
+            # SSE 断言类型
+            elif assert_type == 'sse_event_count':
+                self._validate_sse_event_count(response, assertion)
+            elif assert_type == 'sse_contains':
+                self._validate_sse_contains(response, assertion)
+            elif assert_type == 'sse_event_exists':
+                self._validate_sse_event_exists(response, assertion)
+            elif assert_type == 'sse_event_field':
+                self._validate_sse_event_field(response, assertion)
+            elif assert_type == 'sse_last_event':
+                self._validate_sse_last_event(response, assertion)
+            else:
+                raise ValueError(f"未知的断言类型: {assert_type}")
+        
+        log.info(f"断言通过")
+
+    def get_field_value(self, response, field_path):
+        """
+        根据字段路径获取响应中的值，支持数组索引和多级嵌套。
+        :param response: 响应数据
+        :param field_path: 字段路径，如 data[0].areaName.ids[1].id
+        :return: 字段值或 None
+        """
+        # 使用正则表达式区分数组索引和字段名
+        pattern = re.compile(r'([a-zA-Z_][\w]*)\[(\d+)\]|([a-zA-Z_][\w]*)')
+        value = response
+    
+        # 找到所有匹配的部分并逐一处理
+        for match in pattern.finditer(field_path):
+            field, index, simple_field = match.groups()
+        
+            # 如果是数组形式，例如 data[0]
+            if field and index is not None:
+                value = value.get(field, []) if isinstance(value, dict) else None
+                if isinstance(value, list) and len(value) > int(index):
+                    value = value[int(index)]
+                else:
+                    value = None
+        
+            # 如果是普通字段
+            elif simple_field:
+                value = value.get(simple_field) if isinstance(value, dict) else None
+        
+            if value is None:
+                break
+    
+        return value
+
+
+    def _validate_mysql_query(self, query, expected):
+        """
+        执行 MySQL 查询并验证结果是否等于 expected
+        :param query: 要执行的 MySQL 查询
+        :param expected: 期望值
+        """
+        result = self._execute_query(query)
+        assert result == expected, f"Expected {expected}, but got {result}"
+
+    def _validate_mysql_query_exists(self, query):
+        """
+        执行 MySQL 查询并验证是否返回了至少一行结果
+        :param query: 要执行的 MySQL 查询
+        """
+        result = self._execute_query(query)
+        assert result is not None, f"Expected query to return results, but got None"
+
+    def _validate_mysql_query_true(self, query):
+        """
+        执行 MySQL 查询并验证结果是否为真 (存在)
+        :param query: 要执行的 MySQL 查询
+        """
+        result = self._execute_query(query)
+        assert bool(result), f"Expected query result to be True, but got {result}"
+
+    def _execute_query(self, query):
+        """
+        执行 MySQL 查询并返回结果
+        :param query: 要执行的 MySQL 查询
+        :return: 查询结果
+        """
+        with self.lock:
+            cursor = self.connection.cursor()
+            cursor.execute(query)
+            try:
+                result = cursor.fetchone()
+                log.info(f"MySQL query executed: {query}, Result: {result}")
+            except mysql.connector.Error as err:
+                log.error(f"Error executing query: {query}, Error: {err}")
+                raise
+            cursor.close()
+            return result[0] if result else None
+
+    # ==================== SSE 断言方法 ====================
+
+    def _validate_sse_event_count(self, response, assertion):
+        """
+        验证 SSE 事件数量
+        :param response: SSEResponse 对象
+        :param assertion: 断言配置，支持 expected (精确), min, max
+        """
+        count = response.event_count
+        expected = assertion.get('expected')
+        min_count = assertion.get('min')
+        max_count = assertion.get('max')
+
+        if expected is not None:
+            assert count == expected, f"SSE 事件数量期望 {expected}，实际 {count}"
+        if min_count is not None:
+            assert count >= min_count, f"SSE 事件数量至少 {min_count}，实际 {count}"
+        if max_count is not None:
+            assert count <= max_count, f"SSE 事件数量最多 {max_count}，实际 {count}"
+        log.info(f"SSE 事件数量断言通过: {count}")
+
+    def _validate_sse_contains(self, response, assertion):
+        """
+        验证 SSE 事件中是否包含指定文本
+        :param response: SSEResponse 对象
+        :param assertion: 断言配置，expected 为要查找的文本
+        """
+        expected = assertion.get('expected')
+        assert response.contains(expected), f"SSE 事件中未找到文本: {expected}"
+        log.info(f"SSE 包含断言通过: {expected}")
+
+    def _validate_sse_event_exists(self, response, assertion):
+        """
+        验证是否存在满足条件的 SSE 事件
+        :param response: SSEResponse 对象
+        :param assertion: 断言配置，支持 event_type, data_contains 等条件
+        """
+        conditions = {}
+        if 'event_type' in assertion:
+            conditions['event_type'] = assertion['event_type']
+        if 'data_contains' in assertion:
+            conditions['data_contains'] = assertion['data_contains']
+
+        event = response.find_event(**conditions)
+        assert event is not None, f"未找到满足条件的 SSE 事件: {conditions}"
+        log.info(f"SSE 事件存在断言通过: {conditions}")
+
+    def _validate_sse_event_field(self, response, assertion):
+        """
+        验证指定索引的 SSE 事件的字段值
+        :param response: SSEResponse 对象
+        :param assertion: 断言配置，index 为事件索引，field 为字段路径，expected 为期望值
+        """
+        index = assertion.get('index', 0)
+        field = assertion.get('field')
+        expected = assertion.get('expected')
+
+        event = response.get_event(index)
+        assert event is not None, f"SSE 事件索引 {index} 不存在"
+
+        # 从 event.data 中获取字段值
+        value = self._get_nested_value(event.get('data', {}), field)
+        assert value == expected, f"SSE 事件[{index}].{field} 期望 {expected}，实际 {value}"
+        log.info(f"SSE 事件字段断言通过: [{index}].{field} = {expected}")
+
+    def _validate_sse_last_event(self, response, assertion):
+        """
+        验证最后一个 SSE 事件
+        :param response: SSEResponse 对象
+        :param assertion: 断言配置，支持 event_type, data_contains, field + expected
+        """
+        event = response.get_event(-1)
+        assert event is not None, "没有收到任何 SSE 事件"
+
+        if 'event_type' in assertion:
+            assert event.get('event') == assertion['event_type'], \
+                f"最后事件类型期望 {assertion['event_type']}，实际 {event.get('event')}"
+
+        if 'data_contains' in assertion:
+            assert assertion['data_contains'] in str(event.get('data', '')), \
+                f"最后事件未包含: {assertion['data_contains']}"
+
+        if 'field' in assertion and 'expected' in assertion:
+            value = self._get_nested_value(event.get('data', {}), assertion['field'])
+            assert value == assertion['expected'], \
+                f"最后事件 {assertion['field']} 期望 {assertion['expected']}，实际 {value}"
+
+        log.info(f"SSE 最后事件断言通过")
+
+    def _get_nested_value(self, data, field_path):
+        """从嵌套字典中获取值"""
+        if not field_path or not isinstance(data, dict):
+            return data
+        keys = field_path.split('.')
+        value = data
+        for key in keys:
+            if isinstance(value, dict):
+                value = value.get(key)
+            else:
+                return None
+        return value
+        
+if __name__ == '__main__':
+    class MockResponse:
+        def __init__(self, json_data):
+            self._json_data = json_data
+        
+        def json(self):
+            return self._json_data
+    
+    assert_var = [
+        {
+            "type": "equal",
+            "field": "code",
+            "expected": 0
+        },
+        {
+            "type": "is not None",
+            "field": "data.id"
+        },
+        {
+            "type": "equal",
+            "field": "message",
+            "expected": "success"
+        }
+    ]
+    response_var = {'code': 0, 'message': 'success', 'data': {}}
+
+    AssertHandler().handle_assertion(asserts=assert_var, response=response_var)

atf/core/config_manager.py

@@ -0,0 +1,111 @@
+# @time:    2024-08-01
+# @author:  xiaoqq
+
+import os
+import yaml
+from atf.core.globals import Globals
+from atf.core.log_manager import log
+
+
+class ConfigManager:
+	"""
+	用于处理 config.yaml 的配置管理类
+	"""
+	_config = None  # 类变量，用于存储加载的配置
+	
+	@classmethod
+	def load_config(cls):
+		if cls._config is not None:
+			return cls._config  # 如果已加载，则直接返回
+		
+		# config.yaml 位于项目根目录，core/ 在 atf/ 之下，需要返回两级
+		config_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../config.yaml")
+		try:
+			with open(config_path, 'r') as file:
+				cls._config = yaml.safe_load(file)
+			if cls._config is None:
+				log.error(f"{config_path} 未找到配置信息")
+				raise ValueError(f"{config_path} 未找到配置信息")
+			log.info("读取工程配置信息成功")
+			
+			# 将DingTalk配置信息存入Globals
+			dingtalk_config = cls._config.get('notifications').get("dingtalk")
+			Globals.set("dingtalk", dingtalk_config)
+			
+			return cls._config
+		except FileNotFoundError:
+			log.error(f"未找到配置文件: {config_path}")
+			raise FileNotFoundError(f"未找到配置文件: {config_path}")
+		except yaml.YAMLError as e:
+			log.error(f"YAML 配置文件解析错误: {e}")
+			raise ValueError(f"YAML 配置文件解析失败: {e}")
+	
+	@classmethod
+	def get_project_env_config(cls, project_name, env):
+		"""
+		获取指定项目和环境的配置信息
+		:param project_name: 项目名称
+		:param env: 环境名称 (如 test, pre, online)
+		:return: 项目的环境配置字典或 None
+		"""
+		config = cls.load_config()
+		project_config = config["projects"].get(project_name, None)
+		
+		if project_config is None:
+			return None
+		
+		final_config = {}
+		
+		if "is_scene" in project_config and project_config["is_scene"]:
+			for sub_project in project_config.get("sub_projects", []):
+				sub_project_config = config["projects"].get(sub_project, None)
+				if sub_project_config is None:
+					log.warning(f"子项目{sub_project}在配置文件中不存在")
+					continue
+				
+				sub_project_env_config = sub_project_config.get(env, None)
+				if sub_project_env_config:
+					cls.validate_config(sub_project_env_config)
+					final_config[sub_project] = sub_project_env_config
+				else:
+					log.warning(f"子项目 {sub_project} 中未找到环境 {env} 的配置信息，返回 None")
+					final_config[sub_project] = None
+				# 存储子项目配置信息到Globals中
+				Globals.set(sub_project, sub_project_env_config)
+		else:
+			project_env_config = project_config.get(env, None)
+			if project_env_config:
+				cls.validate_config(project_env_config)
+				final_config[project_name] = project_env_config
+			else:
+				log.warning(f"项目 {project_name} 中未找到环境 {env} 的配置信息，返回 None")
+				final_config[project_name] = None
+			# 存储项目配置信息到Globals中
+			Globals.set(project_name, project_env_config)
+		
+		return final_config
+	
+	@staticmethod
+	def validate_config(project_env_config):
+		"""
+		验证配置文件的项目环境配置中是否有必需字段
+		:param project_env_config: 项目的环境配置字典
+		"""
+		required_keys = ['host', 'is_need_login']  # 需要验证的关键字段
+		for key in required_keys:
+			if key not in project_env_config:
+				log.error(f"{project_env_config} 中缺少必需配置项 {key}")
+				raise ValueError(f"{project_env_config} 中缺少必需配置项 {key}")
+		
+		if project_env_config['is_need_login']:
+			login_config = project_env_config.get('login', {})
+			required_login_keys = ['url', 'method', 'data']
+			for key in required_login_keys:
+				if key not in login_config:
+					log.error(f"{project_env_config} 中登录配置缺失或不完整")
+					raise ValueError(f"{project_env_config} 中登录配置缺失或不完整")
+			
+			
+if __name__ == '__main__':
+	conf = ConfigManager.get_project_env_config(project_name="merchant", env="pre")
+	print(conf)

atf/core/globals.py

@@ -0,0 +1,52 @@
+# @time:    2024-08-16
+# @author:  xiaoqq
+
+import threading
+
+class Globals:
+    """
+    全局变量管理，线程安全
+    """
+    _instance = None
+    _lock = threading.Lock()
+    _data = {}
+
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super(Globals, cls).__new__(cls)
+        return cls._instance
+
+    @classmethod
+    def get_data(cls):
+        with cls._lock:
+            return cls._data.copy()
+
+    @classmethod
+    def set(cls, key, value):
+        with cls._lock:
+            # 仅在数据发生变化时才进行设置
+            if cls._data.get(key) != value:
+                cls._data[key] = value
+
+    @classmethod
+    def get(cls, key):
+        with cls._lock:
+            return cls._data.get(key)
+
+    @classmethod
+    def update(cls, key, sub_key, sub_value):
+        with cls._lock:
+            if key in cls._data:
+                if isinstance(cls._data[key], dict):
+                    cls._data[key][sub_key] = sub_value
+                else:
+                    raise ValueError(f"Cannot update non-dict item in Globals: {key}")
+            else:
+                raise KeyError(f"Key {key} not found in Globals")
+
+    @classmethod
+    def clear(cls):
+        with cls._lock:
+            cls._data.clear()

atf/core/log_manager.py

@@ -0,0 +1,52 @@
+# @time:    2024-08-01
+# @author:  xiaoqq
+
+import os
+from datetime import datetime
+from loguru import logger
+
+class LogManager:
+    '''
+    日志记录器封装
+    '''
+    
+    @staticmethod
+    def setup_logging():
+        root_path = os.path.dirname(os.path.abspath(__file__))  # 根目录
+        log_dir = os.path.join(root_path, "../logs")
+        if not os.path.exists(log_dir):
+            os.makedirs(log_dir)
+        
+        log_name = datetime.now().strftime("%Y-%m-%d")  # 日志文件名命名格式为“年-月-日”
+        sink = os.path.join(log_dir, "{}.log".format(log_name))  # 日志文件路径
+        level = "DEBUG"  # 记录的最低日志级别为DEBUG
+        encoding = "utf-8"  # 写入日志文件时编码格式为utf-8
+        enqueue = True  # 多线程多进程时保证线程安全
+        rotation = "500MB"  # 日志文件最大为500MB，超过则新建文件记录日志
+        retention = "1 week"  # 日志保留时长为1星期，超时则清除
+        
+        logger.add(
+            sink=sink,
+            level=level,
+            encoding=encoding,
+            enqueue=enqueue,
+            rotation=rotation,
+            retention=retention
+        )
+    
+    @staticmethod
+    def get_logger():
+        return logger
+
+# 在工程开始时初始化设置日志记录器
+LogManager.setup_logging()
+
+# 获取日志记录器实例，用于其他模块调用
+log = LogManager.get_logger()
+
+
+if __name__ == '__main__':
+    log.debug("debug消息")
+    log.info("info消息")
+    log.warning("warning消息")
+    log.error("error消息")