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

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

@@ -0,0 +1,122 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+// 模拟依赖
+jest.mock('@modelcontextprotocol/sdk/server/index.js', () => ({
+    Server: jest.fn().mockImplementation(() => ({
+        connect: jest.fn().mockResolvedValue(undefined),
+        registerTool: jest.fn(),
+        registerResource: jest.fn(),
+        registerPrompt: jest.fn()
+    }))
+}));
+jest.mock('@modelcontextprotocol/sdk/server/stdio.js', () => ({
+    StdioServerTransport: jest.fn().mockImplementation(() => ({}))
+}));
+jest.mock('../../src/lib/server/tools.js', () => ({
+    registerTools: jest.fn()
+}));
+jest.mock('../../src/lib/server/resources.js', () => ({
+    registerResources: jest.fn()
+}));
+jest.mock('../../src/lib/server/prompts.js', () => ({
+    registerPrompts: jest.fn()
+}));
+jest.mock('../../src/lib/server/browser.js', () => ({
+    closeBrowserInstance: jest.fn().mockResolvedValue(undefined)
+}));
+jest.mock('../../src/lib/logger.js', () => ({
+    log: jest.fn(),
+    COMPONENTS: {
+        SERVER: 'SERVER'
+    }
+}));
+// 导入被测试的模块和依赖
+import { closeBrowserInstance } from '../../src/lib/server/browser.js';
+import { log } from '../../src/lib/logger.js';
+// 测试信号处理函数
+describe('MCP服务器信号处理测试 (MCP Server Signal Handling Tests)', () => {
+    // 保存原始的process.on和process.exit
+    const originalProcessOn = process.on;
+    const originalProcessExit = process.exit;
+    // 存储信号处理函数
+    let exitHandler;
+    let sigintHandler;
+    let sigtermHandler;
+    let uncaughtExceptionHandler;
+    beforeEach(() => {
+        // 重置所有模拟
+        jest.clearAllMocks();
+        // 模拟process.on
+        process.on = jest.fn().mockImplementation((event, handler) => {
+            // 存储处理函数以便测试
+            if (event === 'exit') {
+                exitHandler = handler;
+            }
+            else if (event === 'SIGINT') {
+                sigintHandler = handler;
+            }
+            else if (event === 'SIGTERM') {
+                sigtermHandler = handler;
+            }
+            else if (event === 'uncaughtException') {
+                uncaughtExceptionHandler = handler;
+            }
+            return process;
+        });
+        // 模拟process.exit
+        process.exit = jest.fn();
+        // 导入startServer函数
+        // 注意：我们需要在每个测试中重新导入，以确保process.on的模拟生效
+        jest.isolateModules(() => {
+            require('../../src/lib/server/index.js').startServer();
+        });
+    });
+    afterEach(() => {
+        // 恢复原始的process.on和process.exit
+        process.on = originalProcessOn;
+        process.exit = originalProcessExit;
+    });
+    test('应该处理SIGINT信号 (Should handle SIGINT signal)', async () => {
+        // 确保处理函数已定义
+        expect(sigintHandler).toBeDefined();
+        // 调用SIGINT处理函数
+        await sigintHandler();
+        // 验证日志被记录
+        expect(log).toHaveBeenCalledWith('server.receivedInterruptSignal', true, {}, expect.anything());
+        // 验证closeBrowserInstance被调用
+        expect(closeBrowserInstance).toHaveBeenCalledWith(false);
+        // 验证process.exit被调用
+        expect(process.exit).toHaveBeenCalledWith(0);
+    });
+    test('应该处理SIGTERM信号 (Should handle SIGTERM signal)', async () => {
+        // 确保处理函数已定义
+        expect(sigtermHandler).toBeDefined();
+        // 调用SIGTERM处理函数
+        await sigtermHandler();
+        // 验证日志被记录
+        expect(log).toHaveBeenCalledWith('server.receivedTerminateSignal', true, {}, expect.anything());
+        // 验证closeBrowserInstance被调用
+        expect(closeBrowserInstance).toHaveBeenCalledWith(false);
+        // 验证process.exit被调用
+        expect(process.exit).toHaveBeenCalledWith(0);
+    });
+    test('应该处理未捕获的异常 (Should handle uncaught exception)', async () => {
+        // 确保处理函数已定义
+        expect(uncaughtExceptionHandler).toBeDefined();
+        // 创建测试错误
+        const testError = new Error('Uncaught error');
+        // 调用uncaughtException处理函数
+        await uncaughtExceptionHandler(testError);
+        // 验证日志被记录
+        expect(log).toHaveBeenCalledWith('server.uncaughtException', true, {
+            error: 'Uncaught error'
+        }, expect.anything());
+        // 验证closeBrowserInstance被调用
+        expect(closeBrowserInstance).toHaveBeenCalledWith(false);
+        // 验证process.exit被调用
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+});

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

@@ -0,0 +1,243 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { registerPrompts } from "../../src/lib/server/prompts.js";
+import { ListPromptsRequestSchema, GetPromptRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+// 模拟i18n模块
+jest.mock('../../src/lib/i18n/index.js', () => ({
+    t: (key) => {
+        const translations = {
+            'prompts.fetchWebsite.description': '获取网站内容',
+            'prompts.url.description': '网站URL',
+            'prompts.format.description': '返回格式',
+            'prompts.useBrowser.description': '是否使用浏览器',
+            'prompts.selector.description': '选择器',
+            'prompts.dataType.description': '数据类型',
+            'prompts.error.description': '错误信息',
+            'prompts.notFound': '提示未找到',
+            'prompts.missingRequiredArg': '缺少必需参数',
+            'prompts.fetchWebsite.result': '获取网站结果',
+            'prompts.fetchWebsite.message': '我需要获取网站内容',
+            'prompts.fetchWebsite.response': '我可以帮你获取网站内容',
+            'prompts.fetchWebsite.instruction': '请获取以下网站',
+            'prompts.fetchWebsite.formatInstruction': '返回格式',
+            'prompts.fetchWebsite.browserInstruction': '使用浏览器',
+            'prompts.yes': '是',
+            'prompts.no': '否',
+            'prompts.extractContent.description': '提取网站内容',
+            'prompts.extractContent.result': '提取内容结果',
+            'prompts.extractContent.message': '请提取以下网站内容',
+            'prompts.extractContent.selectorInstruction': '使用选择器',
+            'prompts.extractContent.dataTypeInstruction': '数据类型',
+            'prompts.debugFetch.description': '调试获取网站内容',
+            'prompts.debugFetch.result': '调试结果',
+            'prompts.debugFetch.message': '调试获取网站内容',
+            'prompts.debugFetch.errorDetails': '错误详情',
+            'prompts.debugFetch.instruction': '请提供调试建议',
+            'prompts.generic.result': '通用结果',
+            'prompts.generic.message': '提示',
+            'prompts.generic.args': '参数'
+        };
+        return translations[key] || key;
+    }
+}));
+// 模拟logger模块
+jest.mock('../../src/lib/logger.js', () => ({
+    log: jest.fn(),
+    COMPONENTS: {
+        PROMPTS: 'prompts'
+    }
+}));
+describe('prompts模块测试', () => {
+    let server;
+    let listPromptsHandler;
+    let getPromptHandler;
+    beforeEach(() => {
+        // 创建模拟Server实例
+        server = {
+            setRequestHandler: jest.fn((schema, handler) => {
+                if (schema === ListPromptsRequestSchema) {
+                    listPromptsHandler = handler;
+                }
+                else if (schema === GetPromptRequestSchema) {
+                    getPromptHandler = handler;
+                }
+            })
+        };
+        // 注册提示处理程序
+        registerPrompts(server);
+    });
+    describe('registerPrompts', () => {
+        it('应该注册ListPromptsRequestSchema和GetPromptRequestSchema处理程序', () => {
+            expect(server.setRequestHandler).toHaveBeenCalledTimes(2);
+            expect(server.setRequestHandler).toHaveBeenCalledWith(ListPromptsRequestSchema, expect.any(Function));
+            expect(server.setRequestHandler).toHaveBeenCalledWith(GetPromptRequestSchema, expect.any(Function));
+        });
+    });
+    describe('ListPromptsRequestSchema处理程序', () => {
+        it('应该返回所有可用的提示', async () => {
+            const request = { params: {} };
+            const response = await listPromptsHandler(request);
+            expect(response).toHaveProperty('prompts');
+            expect(Array.isArray(response.prompts)).toBe(true);
+            expect(response.prompts.length).toBe(3);
+            // 验证返回的提示
+            const promptNames = response.prompts.map((p) => p.name);
+            expect(promptNames).toContain('mult-fetch-mcp:prompt:fetch-website');
+            expect(promptNames).toContain('mult-fetch-mcp:prompt:extract-content');
+            expect(promptNames).toContain('mult-fetch-mcp:prompt:debug-fetch');
+        });
+        it('应该处理debug参数', async () => {
+            const request = { params: { debug: true } };
+            await listPromptsHandler(request);
+            // 验证日志调用
+            expect(require('../../src/lib/logger.js').log).toHaveBeenCalledWith('prompts.list.request', true, { params: { debug: true } }, 'prompts');
+        });
+    });
+    describe('GetPromptRequestSchema处理程序', () => {
+        it('应该处理fetch-website提示', async () => {
+            const request = {
+                params: {
+                    name: 'mult-fetch-mcp:prompt:fetch-website',
+                    arguments: {
+                        url: 'https://example.com',
+                        format: 'html',
+                        useBrowser: false
+                    }
+                }
+            };
+            const response = await getPromptHandler(request);
+            expect(response).toHaveProperty('description');
+            expect(response).toHaveProperty('messages');
+            expect(Array.isArray(response.messages)).toBe(true);
+            expect(response.messages.length).toBe(3);
+            // 验证消息内容
+            const userMessage = response.messages[2];
+            expect(userMessage.role).toBe('user');
+            expect(userMessage.content.type).toBe('text');
+            expect(userMessage.content.text).toContain('https://example.com');
+            expect(userMessage.content.text).toContain('html');
+            expect(userMessage.content.text).toContain('否');
+        });
+        it('应该处理extract-content提示', async () => {
+            const request = {
+                params: {
+                    name: 'mult-fetch-mcp:prompt:extract-content',
+                    arguments: {
+                        url: 'https://example.com',
+                        selector: 'main',
+                        dataType: 'text'
+                    }
+                }
+            };
+            const response = await getPromptHandler(request);
+            expect(response).toHaveProperty('description');
+            expect(response).toHaveProperty('messages');
+            expect(Array.isArray(response.messages)).toBe(true);
+            expect(response.messages.length).toBe(1);
+            // 验证消息内容
+            const userMessage = response.messages[0];
+            expect(userMessage.role).toBe('user');
+            expect(userMessage.content.type).toBe('text');
+            expect(userMessage.content.text).toContain('https://example.com');
+            expect(userMessage.content.text).toContain('main');
+            expect(userMessage.content.text).toContain('text');
+        });
+        it('应该处理debug-fetch提示', async () => {
+            const request = {
+                params: {
+                    name: 'mult-fetch-mcp:prompt:debug-fetch',
+                    arguments: {
+                        url: 'https://example.com',
+                        error: '404 Not Found'
+                    }
+                }
+            };
+            const response = await getPromptHandler(request);
+            expect(response).toHaveProperty('description');
+            expect(response).toHaveProperty('messages');
+            expect(Array.isArray(response.messages)).toBe(true);
+            expect(response.messages.length).toBe(1);
+            // 验证消息内容
+            const userMessage = response.messages[0];
+            expect(userMessage.role).toBe('user');
+            expect(userMessage.content.type).toBe('text');
+            expect(userMessage.content.text).toContain('https://example.com');
+            expect(userMessage.content.text).toContain('404 Not Found');
+        });
+        it('应该处理未知提示', async () => {
+            const request = {
+                params: {
+                    name: 'unknown-prompt',
+                    arguments: {}
+                }
+            };
+            await expect(getPromptHandler(request)).rejects.toThrow('提示未找到');
+        });
+        it('应该检查必需参数', async () => {
+            const request = {
+                params: {
+                    name: 'mult-fetch-mcp:prompt:fetch-website',
+                    arguments: {
+                        // 缺少必需的url参数
+                        format: 'html'
+                    }
+                }
+            };
+            await expect(getPromptHandler(request)).rejects.toThrow('缺少必需参数');
+        });
+        it('应该处理不同类型的useBrowser参数', async () => {
+            // 测试字符串类型的useBrowser
+            const request1 = {
+                params: {
+                    name: 'mult-fetch-mcp:prompt:fetch-website',
+                    arguments: {
+                        url: 'https://example.com',
+                        useBrowser: 'true'
+                    }
+                }
+            };
+            const response1 = await getPromptHandler(request1);
+            expect(response1.messages[2].content.text).toContain('是');
+            // 测试数字类型的useBrowser
+            const request2 = {
+                params: {
+                    name: 'mult-fetch-mcp:prompt:fetch-website',
+                    arguments: {
+                        url: 'https://example.com',
+                        useBrowser: 1
+                    }
+                }
+            };
+            const response2 = await getPromptHandler(request2);
+            expect(response2.messages[2].content.text).toContain('是');
+            // 测试零值
+            const request3 = {
+                params: {
+                    name: 'mult-fetch-mcp:prompt:fetch-website',
+                    arguments: {
+                        url: 'https://example.com',
+                        useBrowser: 0
+                    }
+                }
+            };
+            const response3 = await getPromptHandler(request3);
+            expect(response3.messages[2].content.text).toContain('否');
+        });
+        it('应该使用默认格式', async () => {
+            const request = {
+                params: {
+                    name: 'mult-fetch-mcp:prompt:fetch-website',
+                    arguments: {
+                        url: 'https://example.com'
+                        // 未指定format，应使用默认值html
+                    }
+                }
+            };
+            const response = await getPromptHandler(request);
+            expect(response.messages[2].content.text).toContain('html');
+        });
+    });
+});