// npx/纯净产物环境模拟测试
import { test, expect } from "vitest";
import fs from "fs";
import os from "os";
import path from "path";
import { execSync, spawnSync } from "child_process";
import { fileURLToPath } from "url";
import { dirname } from "path";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
// Helper function to wait for delay
const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
// MCP 连接测试函数
async function testMcpConnection(cliPath) {
let transport = null;
let client = null;
try {
console.log("📡 创建 MCP 客户端...");
// Create client
client = new Client(
{
name: "test-client-npx",
version: "1.0.0",
},
{
capabilities: {},
},
);
// Create stdio transport that spawns the server
transport = new StdioClientTransport({
command: "node",
args: [cliPath],
env: { ...process.env },
});
// Connect client to server
console.log("🔗 连接到 MCP 服务器...");
await client.connect(transport);
// Wait for connection to establish
await delay(3000);
console.log("🔍 测试服务器功能...");
// List tools (this should work since we declared tools capability)
const toolsResult = await client.listTools();
expect(toolsResult.tools).toBeDefined();
expect(Array.isArray(toolsResult.tools)).toBe(true);
expect(toolsResult.tools.length).toBeGreaterThan(0);
console.log(`✅ 服务器暴露了 ${toolsResult.tools.length} 个工具`);
// Test a simple tool call (searchKnowledgeBase should always be available)
const knowledgeTool = toolsResult.tools.find(
(t) => t.name === "searchKnowledgeBase",
);
if (knowledgeTool) {
console.log("🔍 测试 searchKnowledgeBase 工具...");
const knowledgeResult = await client.callTool({
name: "searchKnowledgeBase",
arguments: {
mode: "vector",
id: "cloudbase", // 知识库范围
content: "test", // 检索内容
limit: 1, // 返回结果数量
},
});
expect(knowledgeResult).toBeDefined();
expect(knowledgeResult.content).toBeDefined();
expect(Array.isArray(knowledgeResult.content)).toBe(true);
console.log("✅ searchKnowledgeBase 工具执行成功");
} else {
console.log("⚠️ searchKnowledgeBase 工具未找到，跳过测试");
}
console.log("✅ MCP 连接测试通过");
} catch (error) {
console.error("❌ MCP 连接测试失败:", error);
throw error;
} finally {
// Clean up
if (client) {
try {
await client.close();
console.log("✅ 客户端连接已关闭");
} catch (e) {
console.warn("⚠️ 关闭客户端连接时出错:", e.message);
}
}
if (transport) {
try {
await transport.close();
console.log("✅ 传输连接已关闭");
} catch (e) {
console.warn("⚠️ 关闭传输连接时出错:", e.message);
}
}
}
}
test("npx/纯净产物环境模拟测试", async () => {
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "mcp-npx-test-"));
let tarballPath = "";
let pkgDir = "";
try {
console.log("🔍 开始 npx 环境模拟测试...");
// 1. 打包
console.log("📦 执行 npm pack...");
tarballPath = execSync("npm pack", {
encoding: "utf-8",
cwd: path.join(__dirname, "../mcp"),
})
.split("\n")
.find((line) => line.endsWith(".tgz"))
.trim();
console.log("📦 打包文件:", tarballPath);
// 2. 解包
console.log("📂 解包到临时目录...");
execSync(`tar -xzf ${tarballPath} -C ${tmpDir}`);
pkgDir = path.join(tmpDir, "package");
console.log("📂 解包目录:", pkgDir);
// 3. 安装依赖（只安装 dependencies）
console.log("📥 安装生产依赖...");
execSync("npm install --production", {
cwd: pkgDir,
stdio: "inherit",
});
// 4. 运行 CLI 基础测试
console.log("🚀 测试 CLI 启动...");
const cliPath = path.join(pkgDir, "dist", "cli.cjs");
const result = spawnSync("node", [cliPath, "--help"], {
encoding: "utf-8",
timeout: 30000, // 30秒超时
});
// 5. 检查基础输出
console.log("🔍 检查基础运行结果...");
console.log("退出码:", result.status);
console.log("标准输出长度:", result.stdout?.length || 0);
console.log("错误输出长度:", result.stderr?.length || 0);
// 检查是否有依赖缺失错误
expect(result.stderr).not.toMatch(/MODULE_NOT_FOUND|Cannot find module/);
expect(result.status).toBe(0);
// 可选：检查 stdout 是否包含预期内容
if (result.stdout) {
console.log("✅ CLI 输出正常");
}
// 6. MCP 连接测试
console.log("🔗 开始 MCP 连接测试...");
await testMcpConnection(cliPath);
// 7. 环境信息查询测试
console.log("🔍 开始环境信息查询测试...");
await testEnvironmentInfo(cliPath);
console.log("✅ npx 环境模拟测试通过");
} catch (error) {
console.error("❌ npx 环境模拟测试失败:", error);
throw error;
} finally {
// 清理临时目录和 tar 包
console.log("🧹 清理临时文件...");
try {
fs.rmSync(tmpDir, { recursive: true, force: true });
console.log("✅ 临时目录清理完成");
} catch (e) {
console.warn("⚠️ 临时目录清理失败:", e.message);
}
try {
fs.unlinkSync(tarballPath);
console.log("✅ tar 包清理完成");
} catch (e) {
console.warn("⚠️ tar 包清理失败:", e.message);
}
}
}, 120000); // 增加到 120 秒
// 环境信息查询测试函数
async function testEnvironmentInfo(cliPath) {
let transport = null;
let client = null;
try {
console.log("📡 创建环境信息查询客户端...");
// Create client
client = new Client(
{
name: "test-client-env-info",
version: "1.0.0",
},
{
capabilities: {},
},
);
// Create stdio transport that spawns the server
transport = new StdioClientTransport({
command: "node",
args: [cliPath],
env: { ...process.env },
});
// Connect client to server
console.log("🔗 连接到 MCP 服务器...");
await client.connect(transport);
// Wait for connection to establish
await delay(3000);
console.log("🔍 查询环境信息...");
// List tools to find environment-related tools
const toolsResult = await client.listTools();
const envTools = toolsResult.tools.filter(
(t) =>
t.name.includes("env") ||
t.name.includes("login") ||
t.name.includes("info"),
);
console.log(
`📋 找到 ${envTools.length} 个环境相关工具:`,
envTools.map((t) => t.name),
);
// Test login tool if available (this is a common environment tool)
const loginTool = toolsResult.tools.find((t) => t.name === "login");
if (loginTool) {
console.log("🔐 测试 login 工具...");
try {
const loginResult = await client.callTool({
name: "login",
arguments: {
secretId: "test-secret-id",
secretKey: "test-secret-key",
envId: "test-env-id",
},
});
expect(loginResult).toBeDefined();
expect(loginResult.content).toBeDefined();
expect(Array.isArray(loginResult.content)).toBe(true);
console.log("✅ login 工具执行成功");
console.log(
"Login 结果:",
loginResult.content[0]?.text?.substring(0, 200) + "...",
);
} catch (loginError) {
// Login might fail with test credentials, which is expected
console.log(
"⚠️ login 工具执行失败（使用测试凭据，这是预期的）:",
loginError.message,
);
}
} else {
console.log("⚠️ login 工具未找到，跳过测试");
}
// Test getEnvironmentInfo tool if available
const envInfoTool = toolsResult.tools.find(
(t) => t.name === "getEnvironmentInfo",
);
if (envInfoTool) {
console.log("🌍 测试 getEnvironmentInfo 工具...");
try {
const envInfoResult = await client.callTool({
name: "getEnvironmentInfo",
arguments: {},
});
expect(envInfoResult).toBeDefined();
expect(envInfoResult.content).toBeDefined();
expect(Array.isArray(envInfoResult.content)).toBe(true);
console.log("✅ getEnvironmentInfo 工具执行成功");
console.log(
"环境信息:",
envInfoResult.content[0]?.text?.substring(0, 200) + "...",
);
} catch (envInfoError) {
console.log(
"⚠️ getEnvironmentInfo 工具执行失败（可能需要认证）:",
envInfoError.message,
);
}
} else {
console.log("⚠️ getEnvironmentInfo 工具未找到，跳过测试");
}
// Test listEnvironments tool if available
const listEnvsTool = toolsResult.tools.find(
(t) => t.name === "listEnvironments",
);
if (listEnvsTool) {
console.log("📋 测试 listEnvironments 工具...");
try {
const listEnvsResult = await client.callTool({
name: "listEnvironments",
arguments: {},
});
expect(listEnvsResult).toBeDefined();
expect(listEnvsResult.content).toBeDefined();
expect(Array.isArray(listEnvsResult.content)).toBe(true);
console.log("✅ listEnvironments 工具执行成功");
console.log(
"环境列表:",
listEnvsResult.content[0]?.text?.substring(0, 200) + "...",
);
} catch (listEnvsError) {
console.log(
"⚠️ listEnvironments 工具执行失败（可能需要认证）:",
listEnvsError.message,
);
}
} else {
console.log("⚠️ listEnvironments 工具未找到，跳过测试");
}
console.log("✅ 环境信息查询测试通过");
} catch (error) {
console.error("❌ 环境信息查询测试失败:", error);
throw error;
} finally {
// Clean up
if (client) {
try {
await client.close();
console.log("✅ 环境信息查询客户端连接已关闭");
} catch (e) {
console.warn("⚠️ 关闭环境信息查询客户端连接时出错:", e.message);
}
}
if (transport) {
try {
await transport.close();
console.log("✅ 环境信息查询传输连接已关闭");
} catch (e) {
console.warn("⚠️ 关闭环境信息查询传输连接时出错:", e.message);
}
}
}
}
