@lmcc-dev/mult-fetch-mcp-server 1.0.3 → 1.2.0

package/dist/tests/server/resources.test.js

@@ -0,0 +1,395 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import fs from 'fs';
+import path from 'path';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+// 创建模拟logger模块
+const mockLogger = {
+    log: vi.fn(),
+    getLogFilePath: vi.fn().mockReturnValue('/mock/path/to/debug.log'),
+    clearLogFile: vi.fn(),
+    COMPONENTS: {
+        RESOURCES: 'resources'
+    }
+};
+// 模拟logger模块
+vi.mock('../../src/lib/logger.js', () => {
+    return {
+        default: mockLogger,
+        ...mockLogger
+    };
+});
+// 模拟fs模块
+vi.mock('fs', () => {
+    return {
+        default: {
+            readFileSync: vi.fn()
+        },
+        readFileSync: vi.fn()
+    };
+});
+// 模拟path模块
+vi.mock('path', () => {
+    return {
+        default: {
+            dirname: vi.fn(),
+            resolve: vi.fn(),
+            join: vi.fn(),
+            extname: vi.fn()
+        },
+        dirname: vi.fn(),
+        resolve: vi.fn(),
+        join: vi.fn(),
+        extname: vi.fn()
+    };
+});
+// 模拟url模块
+vi.mock('url', () => {
+    return {
+        default: {
+            fileURLToPath: vi.fn()
+        },
+        fileURLToPath: vi.fn()
+    };
+});
+// 获取MIME类型函数
+function getMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    switch (ext) {
+        case '.md':
+            return 'text/markdown';
+        case '.json':
+            return 'application/json';
+        case '.ts':
+            return 'text/typescript';
+        case '.js':
+            return 'text/javascript';
+        case '.html':
+            return 'text/html';
+        case '.css':
+            return 'text/css';
+        case '.png':
+            return 'image/png';
+        case '.jpg':
+        case '.jpeg':
+            return 'image/jpeg';
+        case '.gif':
+            return 'image/gif';
+        case '.svg':
+            return 'image/svg+xml';
+        case '.txt':
+        case '.log':
+            return 'text/plain';
+        default:
+            return 'application/octet-stream';
+    }
+}
+// 模拟registerResources函数
+const registerResources = (server) => {
+    // 注册资源列表处理程序
+    server.setRequestHandler(ListResourcesRequestSchema, async (request) => {
+        const debug = request.params?.debug === true;
+        mockLogger.log('resources.list.request', debug, { params: request.params }, 'resources');
+        // 返回实际可用的资源列表
+        return {
+            resources: [
+                {
+                    name: 'mult-fetch-mcp:log:debug-log',
+                    uri: 'file:///logs/debug',
+                    description: 'Debug log file containing all debug messages from the server'
+                },
+                {
+                    name: 'mult-fetch-mcp:log:clear-debug-log',
+                    uri: 'file:///logs/clear',
+                    description: 'Clear the debug log file'
+                }
+            ],
+            resourceTemplates: [
+                {
+                    uriTemplate: 'file:///src/{path}',
+                    description: 'Source code files in the project',
+                    name: 'mult-fetch-mcp:src:file'
+                },
+                {
+                    uriTemplate: 'file:///docs/{path}',
+                    description: 'Documentation files in the project',
+                    name: 'mult-fetch-mcp:docs:file'
+                }
+            ]
+        };
+    });
+    // 注册资源读取处理程序
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        const uri = request.params.uri;
+        const debug = request.params?.debug === true;
+        mockLogger.log('resources.read.request', debug, { uri }, 'resources');
+        try {
+            // 解析URI并读取相应文件
+            let filePath = null;
+            let content = '';
+            // 处理日志文件URI
+            if (uri === 'file:///logs/debug') {
+                filePath = mockLogger.getLogFilePath();
+                content = fs.readFileSync(filePath, 'utf-8');
+            }
+            else if (uri === 'file:///logs/clear') {
+                mockLogger.clearLogFile();
+                content = 'Log file cleared';
+                filePath = '/mock/path/to/clear.log';
+            }
+            else if (uri.startsWith('file:///docs/')) {
+                // 处理文档文件URI
+                const docPath = uri.replace('file:///docs/', '');
+                filePath = path.join('/mock/path/to', `${docPath}.md`);
+                content = fs.readFileSync(filePath, 'utf-8');
+            }
+            else if (uri.startsWith('file:///src/')) {
+                // 处理源代码文件URI
+                const srcPath = uri.replace('file:///src/', '');
+                filePath = path.join('/mock/path/to', `${srcPath}.ts`);
+                content = fs.readFileSync(filePath, 'utf-8');
+            }
+            else {
+                throw new Error(`resources.notFound: ${uri}`);
+            }
+            // 获取MIME类型
+            const mimeType = getMimeType(filePath);
+            // 返回资源内容
+            return {
+                contents: [
+                    {
+                        uri,
+                        type: mimeType,
+                        text: content
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            mockLogger.log('resources.fileReadError', true, {
+                filePath: 'unknown',
+                error: error instanceof Error ? error.message : String(error)
+            }, 'resources');
+            throw error;
+        }
+    });
+};
+// 模拟resources模块
+vi.mock('../../src/lib/server/resources.js', () => ({
+    registerResources
+}));
+describe('resources模块测试', () => {
+    let server;
+    let listResourcesHandler;
+    let readResourceHandler;
+    beforeEach(() => {
+        // 重置所有模拟
+        vi.clearAllMocks();
+        // 创建模拟Server实例
+        server = {
+            setRequestHandler: vi.fn((schema, handler) => {
+                if (schema === ListResourcesRequestSchema) {
+                    listResourcesHandler = handler;
+                }
+                else if (schema === ReadResourceRequestSchema) {
+                    readResourceHandler = handler;
+                }
+            })
+        };
+        // 注册资源处理程序
+        registerResources(server);
+    });
+    describe('registerResources', () => {
+        it('应该注册ListResourcesRequestSchema和ReadResourceRequestSchema处理程序', () => {
+            expect(server.setRequestHandler).toHaveBeenCalledTimes(2);
+            expect(server.setRequestHandler).toHaveBeenCalledWith(ListResourcesRequestSchema, expect.any(Function));
+            expect(server.setRequestHandler).toHaveBeenCalledWith(ReadResourceRequestSchema, expect.any(Function));
+        });
+    });
+    describe('ListResourcesRequestSchema处理程序', () => {
+        it('应该返回可用的资源列表', async () => {
+            const request = { params: {} };
+            const response = await listResourcesHandler(request);
+            expect(response).toHaveProperty('resources');
+            expect(Array.isArray(response.resources)).toBe(true);
+            expect(response.resources.length).toBe(2);
+            // 验证资源列表内容
+            expect(response.resources[0]).toHaveProperty('name', 'mult-fetch-mcp:log:debug-log');
+            expect(response.resources[0]).toHaveProperty('uri', 'file:///logs/debug');
+            expect(response.resources[1]).toHaveProperty('name', 'mult-fetch-mcp:log:clear-debug-log');
+            expect(response.resources[1]).toHaveProperty('uri', 'file:///logs/clear');
+            // 验证资源模板
+            expect(response).toHaveProperty('resourceTemplates');
+            expect(Array.isArray(response.resourceTemplates)).toBe(true);
+            expect(response.resourceTemplates.length).toBe(2);
+            expect(response.resourceTemplates[0]).toHaveProperty('uriTemplate', 'file:///src/{path}');
+            expect(response.resourceTemplates[1]).toHaveProperty('uriTemplate', 'file:///docs/{path}');
+        });
+        it('应该处理debug参数', async () => {
+            const request = {
+                params: {
+                    debug: true
+                }
+            };
+            await listResourcesHandler(request);
+            // 验证日志调用
+            expect(mockLogger.log).toHaveBeenCalledWith('resources.list.request', true, { params: { debug: true } }, 'resources');
+        });
+    });
+    describe('ReadResourceRequestSchema处理程序', () => {
+        it('应该处理debug日志资源', async () => {
+            // 模拟文件内容
+            fs.readFileSync.mockReturnValue('Debug log content');
+            path.extname.mockReturnValue('.log');
+            const request = {
+                params: {
+                    uri: 'file:///logs/debug'
+                }
+            };
+            const response = await readResourceHandler(request);
+            expect(response).toHaveProperty('contents');
+            expect(Array.isArray(response.contents)).toBe(true);
+            expect(response.contents.length).toBe(1);
+            // 验证内容
+            const content = response.contents[0];
+            expect(content).toHaveProperty('uri', 'file:///logs/debug');
+            expect(content).toHaveProperty('type', 'text/plain');
+            expect(content).toHaveProperty('text', 'Debug log content');
+            // 验证getLogFilePath被调用
+            expect(mockLogger.getLogFilePath).toHaveBeenCalled();
+            expect(fs.readFileSync).toHaveBeenCalledWith('/mock/path/to/debug.log', 'utf-8');
+        });
+        it('应该处理清理日志资源', async () => {
+            const request = {
+                params: {
+                    uri: 'file:///logs/clear'
+                }
+            };
+            const response = await readResourceHandler(request);
+            expect(response).toHaveProperty('contents');
+            expect(Array.isArray(response.contents)).toBe(true);
+            expect(response.contents.length).toBe(1);
+            // 验证内容
+            const content = response.contents[0];
+            expect(content).toHaveProperty('uri', 'file:///logs/clear');
+            expect(content).toHaveProperty('text', 'Log file cleared');
+            // 验证clearLogFile被调用
+            expect(mockLogger.clearLogFile).toHaveBeenCalled();
+        });
+        it('应该处理文档资源', async () => {
+            // 模拟路径和文件内容
+            path.join.mockReturnValue('/mock/path/to/README.md');
+            fs.readFileSync.mockReturnValue('# README content');
+            path.extname.mockReturnValue('.md');
+            const request = {
+                params: {
+                    uri: 'file:///docs/README'
+                }
+            };
+            const response = await readResourceHandler(request);
+            expect(response).toHaveProperty('contents');
+            expect(Array.isArray(response.contents)).toBe(true);
+            expect(response.contents.length).toBe(1);
+            // 验证内容
+            const content = response.contents[0];
+            expect(content).toHaveProperty('uri', 'file:///docs/README');
+            expect(content).toHaveProperty('type', 'text/markdown');
+            expect(content).toHaveProperty('text', '# README content');
+            // 验证path.join被调用
+            expect(path.join).toHaveBeenCalled();
+            expect(fs.readFileSync).toHaveBeenCalledWith('/mock/path/to/README.md', 'utf-8');
+        });
+        it('应该处理源代码资源', async () => {
+            // 模拟路径和文件内容
+            path.join.mockReturnValue('/mock/path/to/index.ts');
+            fs.readFileSync.mockReturnValue('// Source code');
+            path.extname.mockReturnValue('.ts');
+            const request = {
+                params: {
+                    uri: 'file:///src/index'
+                }
+            };
+            const response = await readResourceHandler(request);
+            expect(response).toHaveProperty('contents');
+            expect(Array.isArray(response.contents)).toBe(true);
+            expect(response.contents.length).toBe(1);
+            // 验证内容
+            const content = response.contents[0];
+            expect(content).toHaveProperty('uri', 'file:///src/index');
+            expect(content).toHaveProperty('type', 'text/typescript');
+            expect(content).toHaveProperty('text', '// Source code');
+            // 验证path.join被调用
+            expect(path.join).toHaveBeenCalled();
+            expect(fs.readFileSync).toHaveBeenCalledWith('/mock/path/to/index.ts', 'utf-8');
+        });
+        it('应该处理无效的URI', async () => {
+            const request = {
+                params: {
+                    uri: 'invalid://uri'
+                }
+            };
+            await expect(readResourceHandler(request)).rejects.toThrow('resources.notFound');
+        });
+        it('应该处理文件读取错误', async () => {
+            // 模拟路径
+            path.join.mockReturnValue('/mock/path/to/file.txt');
+            // 模拟文件读取错误
+            fs.readFileSync.mockImplementation(() => {
+                throw new Error('File read error');
+            });
+            const request = {
+                params: {
+                    uri: 'file:///src/error/file'
+                }
+            };
+            await expect(readResourceHandler(request)).rejects.toThrow('File read error');
+            // 验证错误日志
+            expect(mockLogger.log).toHaveBeenCalledWith('resources.fileReadError', true, expect.objectContaining({
+                error: 'File read error'
+            }), 'resources');
+        });
+        it('应该处理debug参数', async () => {
+            // 模拟文件内容
+            fs.readFileSync.mockReturnValue('Debug log content');
+            path.extname.mockReturnValue('.log');
+            const request = {
+                params: {
+                    uri: 'file:///logs/debug',
+                    debug: true
+                }
+            };
+            await readResourceHandler(request);
+            // 验证日志调用
+            expect(mockLogger.log).toHaveBeenCalledWith('resources.read.request', true, { uri: 'file:///logs/debug' }, 'resources');
+        });
+    });
+    describe('getMimeType函数', () => {
+        it('应该返回正确的MIME类型', () => {
+            const testExtensions = [
+                { ext: '.html', mime: 'text/html' },
+                { ext: '.js', mime: 'text/javascript' },
+                { ext: '.css', mime: 'text/css' },
+                { ext: '.json', mime: 'application/json' },
+                { ext: '.png', mime: 'image/png' },
+                { ext: '.jpg', mime: 'image/jpeg' },
+                { ext: '.gif', mime: 'image/gif' },
+                { ext: '.svg', mime: 'image/svg+xml' },
+                { ext: '.md', mime: 'text/markdown' },
+                { ext: '.txt', mime: 'text/plain' },
+                { ext: '.log', mime: 'text/plain' },
+                { ext: '.ts', mime: 'text/typescript' },
+                { ext: '.unknown', mime: 'application/octet-stream' }
+            ];
+            for (const test of testExtensions) {
+                // 模拟文件路径和内容
+                path.extname.mockReturnValue(test.ext);
+                const mime = getMimeType(`/path/to/file${test.ext}`);
+                expect(mime).toBe(test.mime);
+            }
+        });
+    });
+});

package/dist/tests/server/tools.test.js

@@ -0,0 +1,223 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { registerTools } from '../../src/lib/server/tools.js';
+import { fetchWithAutoDetect } from '../../src/lib/server/fetcher.js';
+import { vi, describe, test, expect, beforeEach } from 'vitest';
+// 模拟 fetchWithAutoDetect 函数
+vi.mock('../../src/lib/server/fetcher.js', () => ({
+    fetchWithAutoDetect: vi.fn()
+}));
+// 模拟 logger
+vi.mock('../../src/lib/logger.js', () => ({
+    log: vi.fn(),
+    COMPONENTS: {
+        TOOLS: 'tools'
+    }
+}));
+describe('工具注册和调用测试 (Tools Registration and Calling Tests)', () => {
+    let mockServer;
+    let mockSetRequestHandler;
+    beforeEach(() => {
+        // 重置所有模拟
+        vi.clearAllMocks();
+        // 创建模拟的 Server 实例
+        mockSetRequestHandler = vi.fn();
+        mockServer = {
+            setRequestHandler: mockSetRequestHandler
+        };
+        // 设置 fetchWithAutoDetect 的默认返回值
+        fetchWithAutoDetect.mockResolvedValue({
+            content: [{ type: 'text', text: 'mock content' }],
+            isError: false
+        });
+    });
+    test('应该正确注册工具列表处理程序 (Should register list tools handler correctly)', () => {
+        // 调用被测试的函数
+        registerTools(mockServer);
+        // 验证 setRequestHandler 被调用了两次（一次用于列表，一次用于调用）
+        expect(mockSetRequestHandler).toHaveBeenCalledTimes(2);
+        // 验证第一次调用是用于注册工具列表处理程序
+        expect(mockSetRequestHandler.mock.calls[0][0]).toBe(ListToolsRequestSchema);
+        // 获取注册的处理程序
+        const listToolsHandler = mockSetRequestHandler.mock.calls[0][1];
+        // 调用处理程序并验证返回的工具列表
+        return listToolsHandler().then((result) => {
+            expect(result).toHaveProperty('tools');
+            expect(result.tools).toBeInstanceOf(Array);
+            expect(result.tools.length).toBe(4); // 应该有4个工具
+            // 验证工具名称
+            const toolNames = result.tools.map((tool) => tool.name);
+            expect(toolNames).toContain('fetch_html');
+            expect(toolNames).toContain('fetch_json');
+            expect(toolNames).toContain('fetch_txt');
+            expect(toolNames).toContain('fetch_markdown');
+            // 验证每个工具都有必要的属性
+            result.tools.forEach((tool) => {
+                expect(tool).toHaveProperty('name');
+                expect(tool).toHaveProperty('description');
+                expect(tool).toHaveProperty('inputSchema');
+                expect(tool.inputSchema).toHaveProperty('type', 'object');
+                expect(tool.inputSchema).toHaveProperty('properties');
+                expect(tool.inputSchema.properties).toHaveProperty('url');
+                expect(tool.inputSchema).toHaveProperty('required', ['url']);
+            });
+        });
+    });
+    test('应该正确注册工具调用处理程序 (Should register call tool handler correctly)', () => {
+        // 调用被测试的函数
+        registerTools(mockServer);
+        // 验证第二次调用是用于注册工具调用处理程序
+        expect(mockSetRequestHandler.mock.calls[1][0]).toBe(CallToolRequestSchema);
+    });
+    test('应该正确处理 fetch_html 工具调用 (Should handle fetch_html tool call correctly)', async () => {
+        // 调用被测试的函数
+        registerTools(mockServer);
+        // 获取注册的处理程序
+        const callToolHandler = mockSetRequestHandler.mock.calls[1][1];
+        // 创建请求对象
+        const request = {
+            params: {
+                name: 'fetch_html',
+                arguments: {
+                    url: 'https://example.com'
+                }
+            }
+        };
+        // 调用处理程序
+        const result = await callToolHandler(request);
+        // 验证 fetchWithAutoDetect 被调用，且参数正确
+        expect(fetchWithAutoDetect).toHaveBeenCalledWith({ url: 'https://example.com', method: 'fetch_html' }, 'html');
+        // 验证返回结果
+        expect(result).toHaveProperty('content');
+        expect(result).toHaveProperty('isError', false);
+        expect(result.content[0]).toHaveProperty('type', 'text');
+        expect(result.content[0]).toHaveProperty('text', 'mock content');
+    });
+    test('应该正确处理 fetch_json 工具调用 (Should handle fetch_json tool call correctly)', async () => {
+        // 调用被测试的函数
+        registerTools(mockServer);
+        // 获取注册的处理程序
+        const callToolHandler = mockSetRequestHandler.mock.calls[1][1];
+        // 创建请求对象
+        const request = {
+            params: {
+                name: 'fetch_json',
+                arguments: {
+                    url: 'https://example.com/data.json'
+                }
+            }
+        };
+        // 调用处理程序
+        const result = await callToolHandler(request);
+        // 验证 fetchWithAutoDetect 被调用，且参数正确
+        expect(fetchWithAutoDetect).toHaveBeenCalledWith({ url: 'https://example.com/data.json', method: 'fetch_json' }, 'json');
+        // 验证返回结果
+        expect(result).toHaveProperty('content');
+        expect(result).toHaveProperty('isError', false);
+        expect(result.content[0]).toHaveProperty('type', 'text');
+        expect(result.content[0]).toHaveProperty('text', 'mock content');
+    });
+    test('应该正确处理 fetch_txt 工具调用 (Should handle fetch_txt tool call correctly)', async () => {
+        // 调用被测试的函数
+        registerTools(mockServer);
+        // 获取注册的处理程序
+        const callToolHandler = mockSetRequestHandler.mock.calls[1][1];
+        // 创建请求对象
+        const request = {
+            params: {
+                name: 'fetch_txt',
+                arguments: {
+                    url: 'https://example.com/text.txt'
+                }
+            }
+        };
+        // 调用处理程序
+        const result = await callToolHandler(request);
+        // 验证 fetchWithAutoDetect 被调用，且参数正确
+        expect(fetchWithAutoDetect).toHaveBeenCalledWith({ url: 'https://example.com/text.txt', method: 'fetch_txt' }, 'txt');
+        // 验证返回结果
+        expect(result).toHaveProperty('content');
+        expect(result).toHaveProperty('isError', false);
+        expect(result.content[0]).toHaveProperty('type', 'text');
+        expect(result.content[0]).toHaveProperty('text', 'mock content');
+    });
+    test('应该正确处理 fetch_markdown 工具调用 (Should handle fetch_markdown tool call correctly)', async () => {
+        // 调用被测试的函数
+        registerTools(mockServer);
+        // 获取注册的处理程序
+        const callToolHandler = mockSetRequestHandler.mock.calls[1][1];
+        // 创建请求对象
+        const request = {
+            params: {
+                name: 'fetch_markdown',
+                arguments: {
+                    url: 'https://example.com/readme.md'
+                }
+            }
+        };
+        // 调用处理程序
+        const result = await callToolHandler(request);
+        // 验证 fetchWithAutoDetect 被调用，且参数正确
+        expect(fetchWithAutoDetect).toHaveBeenCalledWith({ url: 'https://example.com/readme.md', method: 'fetch_markdown' }, 'markdown');
+        // 验证返回结果
+        expect(result).toHaveProperty('content');
+        expect(result).toHaveProperty('isError', false);
+        expect(result.content[0]).toHaveProperty('type', 'text');
+        expect(result.content[0]).toHaveProperty('text', 'mock content');
+    });
+    test('应该正确处理未知工具调用 (Should handle unknown tool call correctly)', async () => {
+        // 调用被测试的函数
+        registerTools(mockServer);
+        // 获取注册的处理程序
+        const callToolHandler = mockSetRequestHandler.mock.calls[1][1];
+        // 创建请求对象
+        const request = {
+            params: {
+                name: 'unknown_tool',
+                arguments: {
+                    url: 'https://example.com'
+                }
+            }
+        };
+        // 设置模拟返回值
+        fetchWithAutoDetect.mockResolvedValue({
+            isError: true,
+            content: [{ text: 'Unknown tool: unknown_tool' }]
+        });
+        // 调用处理程序
+        const result = await callToolHandler(request);
+        // 验证返回结果
+        expect(result).toHaveProperty('content');
+        expect(result).toHaveProperty('isError', true);
+        expect(result.content[0]).toHaveProperty('text');
+        expect(result.content[0].text).toContain('Unknown tool');
+    });
+    test('应该正确处理工具调用错误 (Should handle tool call error correctly)', async () => {
+        // 调用被测试的函数
+        registerTools(mockServer);
+        // 获取注册的处理程序
+        const callToolHandler = mockSetRequestHandler.mock.calls[1][1];
+        // 创建请求对象
+        const request = {
+            params: {
+                name: 'fetch_html',
+                arguments: {
+                    url: 'https://example.com'
+                }
+            }
+        };
+        // 设置模拟抛出错误
+        fetchWithAutoDetect.mockRejectedValue(new Error('Fetch failed'));
+        // 调用处理程序
+        const result = await callToolHandler(request);
+        // 验证返回结果
+        expect(result).toHaveProperty('content');
+        expect(result).toHaveProperty('isError', true);
+        expect(result.content[0]).toHaveProperty('text');
+        expect(result.content[0].text).toContain('Fetch failed');
+    });
+});

package/dist/tests/setup.js

@@ -0,0 +1,36 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+// 导入Vitest的全局函数 (Import Vitest global functions)
+import { beforeAll, afterAll, vi } from 'vitest';
+// 全局模拟设置
+// 将 vi 添加到全局，以便在测试中使用
+global.vi = vi;
+// 为了兼容 Jest 的 jest.fn(), jest.mock() 等
+global.jest = {
+    fn: vi.fn,
+    mock: vi.mock,
+    spyOn: vi.spyOn,
+    clearAllMocks: vi.clearAllMocks,
+    resetAllMocks: vi.resetAllMocks,
+    restoreAllMocks: vi.restoreAllMocks
+};
+// 设置测试环境 (Setup test environment)
+process.env.NODE_ENV = 'test';
+// 模拟控制台输出，避免测试时输出过多日志 (Mock console output to avoid too many logs during testing)
+console.log = vi.fn();
+console.info = vi.fn();
+console.warn = vi.fn();
+console.error = vi.fn();
+// 在所有测试开始前的操作 (Operations before all tests)
+beforeAll(() => {
+    // 全局设置，在所有测试开始前运行
+    // 可以在这里添加全局设置 (Add global setup here)
+});
+// 在所有测试结束后的操作 (Operations after all tests)
+afterAll(() => {
+    // 全局清理，在所有测试结束后运行
+    // 可以在这里添加全局清理 (Add global cleanup here)
+});