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

atf/mcp_server.py

@@ -0,0 +1,169 @@
+"""
+API Auto Test MCP Server
+MCP 服务器主入口
+
+架构说明:
+- mcp/models.py: 所有 Pydantic 数据模型
+- mcp/utils.py: 工具函数
+- mcp/executor.py: 测试执行逻辑
+- mcp/tools/*.py: 各功能工具实现
+"""
+
+from __future__ import annotations
+
+import argparse
+import inspect
+import json
+import os
+import sys
+
+from mcp.server import FastMCP
+
+from atf.core.log_manager import log
+# 导入各工具注册函数
+from atf.mcp.tools.health_tool import register_health_tool
+from atf.mcp.tools.metrics_tools import register_metrics_tools
+from atf.mcp.tools.testcase_tools import register_testcase_tools
+from atf.mcp.tools.unittest_tools import register_unittest_tools
+from atf.mcp.tools.runner_tools import register_runner_tools
+
+
+# 创建 MCP 服务器实例
+mcp = FastMCP(name="api-auto-test-mcp")
+
+
+def register_all_tools() -> None:
+    """注册所有 MCP 工具"""
+    register_health_tool(mcp)
+    register_metrics_tools(mcp)
+    register_testcase_tools(mcp)
+    register_unittest_tools(mcp)
+    register_runner_tools(mcp)
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="API Auto Test MCP Server")
+    parser.add_argument(
+        "--transport",
+        choices=["stdio", "sse"],
+        default=os.getenv("MCP_TRANSPORT", "stdio"),
+        help="传输方式，默认 stdio",
+    )
+    parser.add_argument(
+        "--host",
+        default=os.getenv("MCP_HOST", "127.0.0.1"),
+        help="SSE 监听地址（仅 sse 生效）",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=int(os.getenv("MCP_PORT", "8000")),
+        help="SSE 监听端口（仅 sse 生效）",
+    )
+    parser.add_argument(
+        "--sse-path",
+        default=os.getenv("MCP_SSE_PATH", "/mcp"),
+        help="SSE 路由路径（仅 sse 生效）",
+    )
+    parser.add_argument(
+        "--auth-token",
+        default=os.getenv("MCP_AUTH_TOKEN"),
+        help="SSE 鉴权 Token（仅 sse 生效，建议使用网关/反代统一鉴权）",
+    )
+    return parser
+
+
+def _filter_run_kwargs(kwargs: dict[str, object]) -> dict[str, object]:
+    try:
+        signature = inspect.signature(mcp.run)
+    except (TypeError, ValueError):
+        return kwargs
+
+    if any(param.kind == inspect.Parameter.VAR_KEYWORD for param in signature.parameters.values()):
+        return kwargs
+
+    allowed = {name for name in signature.parameters.keys()}
+    filtered = {key: value for key, value in kwargs.items() if key in allowed}
+    unsupported = set(kwargs) - set(filtered)
+    if unsupported:
+        log.warning(f"SSE 参数未被当前 mcp 版本支持，将忽略: {sorted(unsupported)}")
+    return filtered
+
+
+def main() -> None:
+    """MCP 服务器入口函数，支持 uv run mcp install"""
+    # 检查是否有 install 子命令
+    if len(sys.argv) > 1 and sys.argv[1] == "install":
+        install_mcp_config()
+        return
+
+    # 注册所有工具
+    register_all_tools()
+
+    parser = _build_parser()
+    args = parser.parse_args()
+
+    if args.transport == "stdio":
+        mcp.run("stdio")
+        return
+
+    if not args.auth_token:
+        log.warning("SSE 模式未设置 auth token，建议在网关或反代层做鉴权")
+
+    run_kwargs = {
+        "host": args.host,
+        "port": args.port,
+        "path": args.sse_path,
+    }
+    if args.auth_token:
+        run_kwargs["auth_token"] = args.auth_token
+
+    try:
+        mcp.run("sse", **_filter_run_kwargs(run_kwargs))
+    except TypeError as exc:
+        log.error(f"SSE 启动失败，请检查 mcp 版本与参数兼容性: {exc}")
+        raise
+
+
+def install_mcp_config() -> None:
+    """安装 MCP 配置到 Claude Code"""
+    mcp_config = {
+        "command": "api-auto-test-mcp",
+        "args": ["--workspace", "${workspace}"]
+    }
+
+    # 尝试找到 Claude Code 的 MCP 配置文件
+    config_path = None
+    for path in [
+        os.path.expanduser("~/.claude/.mcp.json"),
+        os.path.expanduser("~/.config/claude/mcp_settings.json"),
+    ]:
+        if os.path.exists(path):
+            config_path = path
+            break
+
+    if config_path:
+        with open(config_path, 'r') as f:
+            try:
+                config = json.load(f)
+            except:
+                config = {}
+    else:
+        config_path = os.path.expanduser("~/.claude/.mcp.json")
+        os.makedirs(os.path.dirname(config_path), exist_ok=True)
+        config = {}
+
+    mcp_servers = config.get("mcpServers", {})
+    mcp_servers["api-auto-test-mcp"] = mcp_config
+    config["mcpServers"] = mcp_servers
+
+    with open(config_path, 'w') as f:
+        json.dump(config, f, indent=2)
+
+    print(f"已配置 MCP 服务器到: {config_path}")
+    print(f"配置内容: {json.dumps(mcp_config, indent=2)}")
+    print("\n请重启 Claude Code 以加载新的 MCP 服务器")
+
+
+if __name__ == "__main__":
+    main()

atf/runner.py

@@ -0,0 +1,134 @@
+# @time:    2024-08-16
+# @author:  xiaoqq
+
+import os
+import pytest
+from atf.core.config_manager import ConfigManager
+from atf.core.log_manager import logger
+from atf.core.globals import Globals
+from atf.core.log_manager import log
+from atf.handlers.notification_handler import NotificationHandler
+from atf.handlers.report_generator import ReportGenerator
+from atf.core.login_handler import LoginHandler
+
+def execute_test_cases(testcases, env, report_type):
+    """
+    根据传入的 testcases 参数执行指定的测试用例
+    :param testcases: 测试用例路径列表（目录或文件）
+    :param env: 环境名称
+    """
+    config_manager = ConfigManager()
+    login_handler = LoginHandler()
+    projects_config = {}
+
+    # 当前执行环境存入全局变量
+    Globals.set('env', env)
+
+    # 遍历所有测试用例路径
+    for testcase_path in testcases:
+        if os.path.isdir(testcase_path):
+            project_name = get_project_name_from_path(testcase_path)
+            project_env_config = config_manager.get_project_env_config(project_name, env)
+            if project_env_config is not None:
+                projects_config.update(project_env_config)
+            else:
+                log.warning(f"{project_name} 的配置未找到，跳过该项目。")
+        elif os.path.isfile(testcase_path):
+            project_name = get_project_name_from_path(os.path.dirname(testcase_path))
+            project_env_config = config_manager.get_project_env_config(project_name, env)
+            if project_env_config is not None:
+                projects_config.update(project_env_config)
+            else:
+                log.warning(f"{project_name} 的配置未找到，跳过该项目。")
+
+    # 判断项目是否需要登录获取token，需要则登录获取token存入全局变量
+    for project_name, project_config in projects_config.items():
+        project_env_config = config_manager.get_project_env_config(project_name, env)
+        token = login_handler.login_if_needed(project_name, project_env_config.get(project_name), env)
+        if token:
+            # 将 token 存入全局变量
+            Globals.update(project_name, "token", token)
+
+    log.info(f"工程配置信息更新：{Globals.get_data()}")
+
+    # 测试报告处理，根据 report 类型准备报告目录和文件
+    report_generator = ReportGenerator(report_type, env)
+    if report_type == 'allure':
+        report_generator.prepare_allure_report()
+        pytest_args = [f'--alluredir={report_generator.allure_results_dir}']
+    elif report_type == 'pytest-html':
+        report_generator.prepare_pytest_html_report()
+        pytest_args = [f'--html={report_generator.html_report_path}', '--self-contained-html']
+    else:
+        pytest_args = []
+
+    for testcase_path in testcases:
+        pytest_args.append(testcase_path)
+
+    try:
+        pytest.main(pytest_args)
+        logger.info(f"所有测试用例执行完成。")
+    except Exception as e:
+        logger.error(f"执行所有测试用例时出错: {str(e)}")
+
+    if report_type == 'allure':
+        report_generator.generate_allure_report()
+
+def get_project_name_from_path(path):
+    """
+    根据路径获取项目名称
+    :param path: 路径字符串
+    :return: 项目名称
+    """
+    parts = os.path.normpath(path).split(os.sep)
+    # 确保有足够的部分返回项目名称
+    if len(parts) > 1:
+        return parts[1]
+    elif len(parts) == 1:
+        return parts[0]
+    return None
+
+def run_tests(testcases=None, env=None, report_type=None):
+    """
+    主运行函数，执行指定的测试用例
+    :param testcases: 测试用例路径列表（目录或文件），默认为 None 则执行所有
+    :param env: 执行环境，可选参数，默认为 None 则执行 test 环境
+    :param report: 报告类型（allure 或 pytest-html），默认为 pytest-html
+    """
+    if testcases is None:
+        # 获取所有嵌套的测试用例路径
+        testcases = [os.path.join(root, file)
+                     for root, dirs, files in os.walk('test_cases')
+                     for file in files if file.endswith('.py')]
+    elif testcases == ['test_cases/']:
+        # 当指定为 test_cases/ 时，获取该目录下所有的子文件夹
+        testcases = [os.path.join('test_cases', d)
+                     for d in os.listdir('test_cases')
+                     if os.path.isdir(os.path.join('test_cases', d))]
+        
+    if env is None:
+        env = 'pre'
+        
+    if report_type is None:
+        report_type = 'pytest-html'
+
+    execute_test_cases(testcases, env, report_type)
+    
+    results = Globals.get('test_results')
+    webhook = Globals.get('dingtalk').get('webhook')
+    secret = Globals.get('dingtalk').get('secret')
+    NotificationHandler(webhook, secret).send_markdown_msg(
+        conclusion=results['conclusion'],
+        total=results['total'],
+        passed=results['passed'],
+        failed=results['failed'],
+        error=results['error'],
+        skipped=results['skipped'],
+        start_time=results['start_time'],
+        duration=results['duration']
+    )
+
+
+if __name__ == '__main__':
+    # report_type 可以为allure、pytest-html，默认pytest-html
+    run_tests(testcases=['test_cases/'], env='pre', report_type='allure')

atf/unit_case_generator.py

@@ -0,0 +1,337 @@
+# @time:    2024-12-25
+# @author:  auto-generated
+
+import os
+from pathlib import Path
+
+import yaml
+
+from atf.core.log_manager import log
+
+
+class UnitCaseGenerator:
+    """单元测试用例文件生成器"""
+
+    def generate_unit_tests(self, yaml_file: str, output_dir: str | None = None, overwrite: bool = False) -> str | None:
+        """
+        根据 YAML 文件生成单元测试用例
+        :param yaml_file: YAML 文件路径
+        :param output_dir: 输出目录
+        :param overwrite: 是否覆盖已存在的文件
+        :return: 生成的文件路径
+        """
+        test_data = self._load_yaml(yaml_file)
+        if not test_data:
+            return None
+
+        if not self._validate_unittest_data(test_data):
+            log.warning(f"{yaml_file} 数据校验不通过，跳过生成。")
+            return None
+
+        unittest_data = test_data["unittest"]
+        file_path = self._get_output_path(yaml_file, unittest_data["name"], output_dir)
+
+        if os.path.exists(file_path):
+            if overwrite:
+                log.info(f"覆盖已存在的测试用例文件: {file_path}")
+            else:
+                log.info(f"测试用例文件已存在，跳过生成: {file_path}")
+                return None
+
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        self._generate_file(file_path, yaml_file, unittest_data)
+        log.info(f"已生成单元测试文件: {file_path}")
+        return file_path
+
+    def _load_yaml(self, yaml_file: str) -> dict | None:
+        """加载 YAML 文件"""
+        try:
+            with open(yaml_file, "r", encoding="utf-8") as f:
+                return yaml.safe_load(f)
+        except FileNotFoundError:
+            log.error(f"未找到文件: {yaml_file}")
+        except yaml.YAMLError as e:
+            log.error(f"YAML 解析错误: {e}")
+        return None
+
+    def _validate_unittest_data(self, data: dict) -> bool:
+        """校验单元测试数据"""
+        if not data.get("unittest"):
+            log.error("数据必须包含 'unittest' 键")
+            return False
+
+        ut = data["unittest"]
+        if not ut.get("name"):
+            log.error("unittest.name 不能为空")
+            return False
+
+        if not ut.get("target") or not ut["target"].get("module"):
+            log.error("unittest.target.module 不能为空")
+            return False
+
+        if not ut.get("cases"):
+            log.error("unittest.cases 不能为空")
+            return False
+
+        for case in ut["cases"]:
+            if not case.get("id"):
+                log.error("unittest.cases.id 不能为空")
+                return False
+
+        return True
+
+    def _get_output_path(self, yaml_file: str, name: str, output_dir: str | None) -> str:
+        """获取输出文件路径"""
+        relative_path = os.path.relpath(yaml_file, "tests")
+        path_parts = relative_path.split(os.sep)
+        if path_parts:
+            path_parts.pop()  # 移除文件名
+        dir_path = os.path.join(*path_parts) if path_parts else ""
+
+        file_name = f"test_{name}.py"
+        base_dir = output_dir or "test_cases"
+        return os.path.join(base_dir, dir_path, file_name)
+
+    def _generate_file(self, file_path: str, yaml_file: str, ut: dict) -> None:
+        """生成测试文件"""
+        with open(file_path, "w", encoding="utf-8") as f:
+            self._write_imports(f, ut)
+            self._write_class_header(f, ut)
+            self._write_test_methods(f, ut, yaml_file)
+
+    def _write_imports(self, f, ut: dict) -> None:
+        """写入导入语句"""
+        f.write("# Auto-generated unit test module\n\n")
+
+        # 写入运行方式注释（根据 env_type）
+        env_type = ut.get("env_type", "venv")
+        if env_type == "venv":
+            f.write("# 运行方式: source .venv/bin/activate && pytest test_cases/ -v\n\n")
+        elif env_type == "conda":
+            f.write("# 运行方式: conda activate <env_name> && pytest test_cases/ -v\n\n")
+        elif env_type == "uv":
+            f.write("# 运行方式: uv run pytest test_cases/ -v\n\n")
+
+        f.write("import pytest\n")
+        f.write("from unittest.mock import patch, MagicMock, call\n")
+        f.write("import allure\n")
+        f.write("import yaml\n\n")
+
+        # 导入被测模块
+        target = ut["target"]
+        module = target["module"]
+        class_name = target.get("class")
+        func_name = target.get("function")
+
+        if class_name:
+            f.write(f"from {module} import {class_name}\n\n")
+        elif func_name:
+            f.write(f"from {module} import {func_name}\n\n")
+        else:
+            f.write(f"import {module}\n\n")
+
+    def _write_class_header(self, f, ut: dict) -> None:
+        """写入类定义和装饰器"""
+        name = ut["name"]
+        class_name = "".join(s.capitalize() for s in name.split("_"))
+        allure_cfg = ut.get("allure", {})
+
+        epic = allure_cfg.get("epic", "单元测试")
+        feature = allure_cfg.get("feature")
+
+        f.write(f"@allure.epic('{epic}')\n")
+        if feature:
+            f.write(f"@allure.feature('{feature}')\n")
+        f.write(f"class Test{class_name}:\n")
+        f.write(f'    """单元测试: {ut.get("description", name)}"""\n\n')
+
+    def _write_test_methods(self, f, ut: dict, yaml_file: str) -> None:
+        """写入测试方法"""
+        target = ut["target"]
+        allure_cfg = ut.get("allure", {})
+        story = allure_cfg.get("story", ut["name"])
+
+        for case in ut["cases"]:
+            self._write_single_test(f, case, target, story)
+
+    def _write_single_test(self, f, case: dict, target: dict, story: str) -> None:
+        """写入单个测试方法"""
+        case_id = case["id"]
+        desc = case.get("description", case_id)
+        mocks = case.get("mocks", [])
+
+        # 写入装饰器
+        f.write(f"    @allure.story('{story}')\n")
+        self._write_mock_decorators(f, mocks)
+
+        # 写入方法签名
+        mock_params = self._get_mock_params(mocks)
+        f.write(f"    def {case_id}(self{mock_params}):\n")
+        f.write(f'        """{desc}"""\n')
+
+        # 写入 mock 配置
+        self._write_mock_setup(f, mocks)
+
+        # 写入执行代码
+        self._write_execution(f, case, target)
+
+        # 写入断言
+        self._write_assertions(f, case, mocks)
+
+        f.write("\n")
+
+    def _write_mock_decorators(self, f, mocks: list) -> None:
+        """写入 mock 装饰器"""
+        for mock in reversed(mocks):
+            target = mock["target"]
+            method = mock.get("method")
+            if method:
+                f.write(f"    @patch('{target}.{method}')\n")
+            else:
+                f.write(f"    @patch('{target}')\n")
+
+    def _get_mock_params(self, mocks: list) -> str:
+        """获取 mock 参数列表"""
+        if not mocks:
+            return ""
+        params = []
+        for mock in mocks:
+            name = self._get_mock_var_name(mock)
+            params.append(name)
+        return ", " + ", ".join(params)
+
+    def _get_mock_var_name(self, mock: dict) -> str:
+        """获取 mock 变量名"""
+        target = mock["target"]
+        method = mock.get("method")
+        if method:
+            return f"mock_{method.lower()}"
+        parts = target.split(".")
+        return f"mock_{parts[-1].lower()}"
+
+    def _write_mock_setup(self, f, mocks: list) -> None:
+        """写入 mock 配置"""
+        for mock in mocks:
+            var_name = self._get_mock_var_name(mock)
+            ret_val = mock.get("return_value")
+            side_effect = mock.get("side_effect")
+
+            if ret_val is not None:
+                f.write(f"        {var_name}.return_value = {repr(ret_val)}\n")
+            if side_effect is not None:
+                f.write(f"        {var_name}.side_effect = {repr(side_effect)}\n")
+
+    def _write_execution(self, f, case: dict, target: dict) -> None:
+        """写入执行代码"""
+        inputs = case.get("inputs", {})
+        args = inputs.get("args", [])
+        kwargs = inputs.get("kwargs", {})
+
+        class_name = target.get("class")
+        func_name = target.get("function")
+
+        f.write("\n        # 执行\n")
+
+        # 构建参数字符串
+        args_str = ", ".join(repr(a) for a in args)
+        kwargs_str = ", ".join(f"{k}={repr(v)}" for k, v in kwargs.items())
+        all_args = ", ".join(filter(None, [args_str, kwargs_str]))
+
+        if class_name and func_name:
+            f.write(f"        instance = {class_name}()\n")
+            f.write(f"        result = instance.{func_name}({all_args})\n")
+        elif class_name:
+            f.write(f"        result = {class_name}({all_args})\n")
+        elif func_name:
+            f.write(f"        result = {func_name}({all_args})\n")
+        else:
+            f.write(f"        result = None  # TODO: 补充执行逻辑\n")
+
+    def _write_assertions(self, f, case: dict, mocks: list) -> None:
+        """写入断言"""
+        asserts = case.get("assert", [])
+        if not asserts:
+            return
+
+        f.write("\n        # 断言\n")
+        mock_var_map = {self._get_mock_key(m): self._get_mock_var_name(m) for m in mocks}
+
+        for assertion in asserts:
+            self._write_single_assertion(f, assertion, mock_var_map)
+
+    def _get_mock_key(self, mock: dict) -> str:
+        """获取 mock 键名"""
+        target = mock["target"]
+        method = mock.get("method")
+        parts = target.split(".")
+        if method:
+            return f"{parts[-1]}.{method}"
+        return parts[-1]
+
+    def _write_single_assertion(self, f, assertion: dict, mock_var_map: dict) -> None:
+        """写入单个断言"""
+        assert_type = assertion["type"]
+        field = assertion.get("field")
+        expected = assertion.get("expected")
+        mock_name = assertion.get("mock")
+        args = assertion.get("args", [])
+        kwargs = assertion.get("kwargs", {})
+        exception = assertion.get("exception")
+        message = assertion.get("message")
+
+        if assert_type == "equals":
+            if field and field != "result":
+                f.write(f"        assert result{self._parse_field(field)} == {repr(expected)}\n")
+            else:
+                f.write(f"        assert result == {repr(expected)}\n")
+
+        elif assert_type == "not_equals":
+            if field and field != "result":
+                f.write(f"        assert result{self._parse_field(field)} != {repr(expected)}\n")
+            else:
+                f.write(f"        assert result != {repr(expected)}\n")
+
+        elif assert_type == "contains":
+            f.write(f"        assert {repr(expected)} in result\n")
+
+        elif assert_type == "is_none":
+            f.write(f"        assert result is None\n")
+
+        elif assert_type == "is_not_none":
+            f.write(f"        assert result is not None\n")
+
+        elif assert_type == "called_once" and mock_name:
+            var = mock_var_map.get(mock_name, f"mock_{mock_name.lower()}")
+            f.write(f"        {var}.assert_called_once()\n")
+
+        elif assert_type == "called_with" and mock_name:
+            var = mock_var_map.get(mock_name, f"mock_{mock_name.lower()}")
+            args_str = ", ".join(repr(a) for a in args)
+            kwargs_str = ", ".join(f"{k}={repr(v)}" for k, v in kwargs.items())
+            all_args = ", ".join(filter(None, [args_str, kwargs_str]))
+            f.write(f"        {var}.assert_called_with({all_args})\n")
+
+        elif assert_type == "not_called" and mock_name:
+            var = mock_var_map.get(mock_name, f"mock_{mock_name.lower()}")
+            f.write(f"        {var}.assert_not_called()\n")
+
+        elif assert_type == "raises" and exception:
+            match_str = f", match={repr(message)}" if message else ""
+            f.write(f"        # 注意: raises 断言需要包裹执行代码\n")
+            f.write(f"        # with pytest.raises({exception}{match_str}):\n")
+            f.write(f"        #     执行代码\n")
+
+    def _parse_field(self, field: str) -> str:
+        """解析字段路径为 Python 访问语法"""
+        if not field:
+            return ""
+        if field.startswith("$."):
+            field = field[2:]
+        parts = field.split(".")
+        result = ""
+        for part in parts:
+            if part.isdigit():
+                result += f"[{part}]"
+            else:
+                result += f"['{part}']"
+        return result

atf/utils/__init__.py

@@ -0,0 +1,2 @@
+# 工具函数模块
+# 可以在这里导入自定义工具函数