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

package/dist/tests/client.test.js

@@ -5,13 +5,14 @@
  */
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { vi, describe, test, expect, beforeEach, afterAll } from 'vitest';
 // 保存原始值以便在测试后恢复
 const originalArgv = process.argv;
 const originalExit = process.exit;
 const originalStdoutWrite = process.stdout.write;
 // 模拟 logger 模块
-const mockLog = jest.fn();
-jest.mock('../src/lib/logger.js', () => ({
+const mockLog = vi.fn();
+vi.mock('../src/lib/logger.js', () => ({
     log: mockLog,
     COMPONENTS: {
         CLIENT: 'CLIENT',
@@ -21,27 +22,27 @@ jest.mock('../src/lib/logger.js', () => ({
     }
 }));
 // 模拟依赖模块
-jest.mock('@modelcontextprotocol/sdk/client/index.js', () => ({
-    Client: jest.fn().mockImplementation(() => ({
-        connect: jest.fn().mockResolvedValue(undefined),
-        callTool: jest.fn(),
-        close: jest.fn().mockResolvedValue(undefined)
+vi.mock('@modelcontextprotocol/sdk/client/index.js', () => ({
+    Client: vi.fn().mockImplementation(() => ({
+        connect: vi.fn().mockResolvedValue(undefined),
+        callTool: vi.fn(),
+        close: vi.fn().mockResolvedValue(undefined)
     }))
 }));
-jest.mock('@modelcontextprotocol/sdk/client/stdio.js', () => ({
-    StdioClientTransport: jest.fn().mockImplementation(() => ({}))
+vi.mock('@modelcontextprotocol/sdk/client/stdio.js', () => ({
+    StdioClientTransport: vi.fn().mockImplementation(() => ({}))
 }));
-jest.mock('child_process', () => ({
-    execSync: jest.fn()
+vi.mock('child_process', () => ({
+    execSync: vi.fn()
 }));
 // 模拟 process.exit
-jest.spyOn(process, 'exit').mockImplementation((code) => {
+vi.spyOn(process, 'exit').mockImplementation((code) => {
     console.log(`[模拟] process.exit(${code})`);
     return undefined;
 });
 // 创建模拟的客户端模块
 const mockClientModule = {
-    responseRequiresBrowser: jest.fn((response, debug = false) => {
+    responseRequiresBrowser: vi.fn((response, debug = false) => {
         if (response.isError) {
             const errorText = response.content[0].text.toLowerCase();
             if (debug) {
@@ -58,7 +59,7 @@ const mockClientModule = {
         }
         return false;
     }),
-    smartFetch: jest.fn(async (params) => {
+    smartFetch: vi.fn(async (params) => {
         const mockClient = new Client({
             name: "fetch-mcp-client",
             version: "1.0.0"
@@ -84,7 +85,7 @@ const mockClientModule = {
             await mockClient.close();
         }
     }),
-    main: jest.fn(() => {
+    main: vi.fn(() => {
         // 检查命令行参数
         if (process.argv.length < 4) {
             mockLog('client.usageInfo', true, {}, 'CLIENT');
@@ -107,12 +108,12 @@ const mockClientModule = {
     })
 };
 // 模拟 client.ts 模块
-jest.mock('../src/client.js', () => mockClientModule, { virtual: true });
+vi.mock('../src/client.ts', () => mockClientModule);
 describe('client.ts 测试', () => {
     // 在每个测试前重置模拟
     beforeEach(() => {
-        jest.resetModules();
-        jest.clearAllMocks();
+        vi.resetModules();
+        vi.clearAllMocks();
     });
     // 在所有测试后恢复原始值
     afterAll(() => {
@@ -121,37 +122,19 @@ describe('client.ts 测试', () => {
     });
     describe('responseRequiresBrowser 函数测试', () => {
         test('应该在响应包含 403 错误时返回 true', () => {
-            // 模拟依赖
-            jest.doMock('../src/lib/logger.js', () => ({
-                log: jest.fn(),
-                COMPONENTS: {
-                    CLIENT: 'CLIENT'
-                }
-            }));
-            // 导入被测试的模块
-            const { responseRequiresBrowser } = require('../src/client.js');
             const response = {
                 isError: true,
                 content: [{ text: '403 Forbidden' }]
             };
-            const result = responseRequiresBrowser(response, true);
+            const result = mockClientModule.responseRequiresBrowser(response, true);
             expect(result).toBe(true);
         });
         test('应该在响应不是错误时返回 false', () => {
-            // 模拟依赖
-            jest.doMock('../src/lib/logger.js', () => ({
-                log: jest.fn(),
-                COMPONENTS: {
-                    CLIENT: 'CLIENT'
-                }
-            }));
-            // 导入被测试的模块
-            const { responseRequiresBrowser } = require('../src/client.js');
             const response = {
                 isError: false,
                 content: [{ text: 'Success' }]
             };
-            const result = responseRequiresBrowser(response);
+            const result = mockClientModule.responseRequiresBrowser(response);
             expect(result).toBe(false);
         });
     });
@@ -163,11 +146,11 @@ describe('client.ts 测试', () => {
                 content: [{ text: '<html><body>Success</body></html>' }]
             };
             // 设置 callTool 的返回值
-            const mockCallTool = jest.fn().mockResolvedValue(mockResult);
+            const mockCallTool = vi.fn().mockResolvedValue(mockResult);
             Client.mockImplementation(() => ({
-                connect: jest.fn().mockResolvedValue(undefined),
+                connect: vi.fn().mockResolvedValue(undefined),
                 callTool: mockCallTool,
-                close: jest.fn().mockResolvedValue(undefined)
+                close: vi.fn().mockResolvedValue(undefined)
             }));
             // 调用函数
             const result = await mockClientModule.smartFetch({
@@ -189,10 +172,10 @@ describe('client.ts 测试', () => {
         });
         test('应该在任何情况下都关闭客户端连接', async () => {
             // 模拟 callTool 抛出错误
-            const mockClose = jest.fn().mockResolvedValue(undefined);
+            const mockClose = vi.fn().mockResolvedValue(undefined);
             Client.mockImplementation(() => ({
-                connect: jest.fn().mockResolvedValue(undefined),
-                callTool: jest.fn().mockRejectedValue(new Error('Test error')),
+                connect: vi.fn().mockResolvedValue(undefined),
+                callTool: vi.fn().mockRejectedValue(new Error('Test error')),
                 close: mockClose
             }));
             // 调用函数并捕获错误
@@ -206,45 +189,23 @@ describe('client.ts 测试', () => {
     });
     describe('main 函数测试', () => {
         test('应该在参数不足时显示使用信息并退出', () => {
-            // 保存原始的 process.argv
-            const testArgv = process.argv;
-            try {
-                // 设置参数不足
-                process.argv = ['node', 'client.js'];
-                // 重置 mockLog 函数
-                mockLog.mockClear();
-                // 调用 main 函数
-                mockClientModule.main();
-                // 验证 log 函数被调用
-                expect(mockLog).toHaveBeenCalledWith('client.usageInfo', true, {}, 'CLIENT');
-                expect(mockLog).toHaveBeenCalledWith('client.exampleUsage', true, {}, 'CLIENT');
-                // 验证 process.exit 被调用
-                expect(process.exit).toHaveBeenCalledWith(1);
-            }
-            finally {
-                // 恢复原始的 process.argv
-                process.argv = testArgv;
-            }
+            // 设置命令行参数
+            process.argv = ['node', 'client.js'];
+            // 调用函数
+            mockClientModule.main();
+            // 验证日志和退出
+            expect(mockLog).toHaveBeenCalledWith('client.usageInfo', true, {}, 'CLIENT');
+            expect(mockLog).toHaveBeenCalledWith('client.exampleUsage', true, {}, 'CLIENT');
+            expect(process.exit).toHaveBeenCalledWith(1);
         });
         test('应该在 JSON 解析失败时显示错误并退出', () => {
-            // 保存原始的 process.argv
-            const testArgv = process.argv;
-            try {
-                // 设置无效的 JSON
-                process.argv = ['node', 'client.js', 'fetch_html', 'invalid-json'];
-                // 重置 mockLog 函数
-                mockLog.mockClear();
-                // 调用 main 函数
-                mockClientModule.main();
-                // 验证 log 函数被调用
-                expect(mockLog).toHaveBeenCalledWith('client.invalidJson', true, {}, 'CLIENT');
-                // 验证 process.exit 被调用
-                expect(process.exit).toHaveBeenCalledWith(1);
-            }
-            finally {
-                // 恢复原始的 process.argv
-                process.argv = testArgv;
-            }
+            // 设置命令行参数
+            process.argv = ['node', 'client.js', 'fetch_html', 'invalid-json'];
+            // 调用函数
+            mockClientModule.main();
+            // 验证日志和退出
+            expect(mockLog).toHaveBeenCalledWith('client.invalidJson', true, {}, 'CLIENT');
+            expect(process.exit).toHaveBeenCalledWith(1);
         });
     });
 });

package/dist/tests/fetch.test.js

@@ -0,0 +1,70 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { describe, expect, test, beforeEach, vi } from 'vitest';
+import { fetchHtml, fetchJson, fetchTxt, fetchMarkdown } from '../src/lib/fetch.js';
+import { Fetcher } from '../src/lib/fetchers/index.js';
+// Mock Fetcher
+vi.mock('../src/lib/fetchers/index.js', () => ({
+    Fetcher: {
+        html: vi.fn(),
+        json: vi.fn(),
+        txt: vi.fn(),
+        markdown: vi.fn()
+    }
+}));
+describe('fetch 函数测试 (fetch functions tests)', () => {
+    // 模拟响应
+    const mockResponse = {
+        content: [{ type: 'text', text: '测试内容' }],
+        isError: false
+    };
+    // 测试请求参数
+    const testPayload = {
+        url: 'https://example.com',
+        debug: true
+    };
+    beforeEach(() => {
+        // 重置所有 mock
+        vi.clearAllMocks();
+        // 设置 Fetcher 方法的返回值
+        Fetcher.html.mockResolvedValue(mockResponse);
+        Fetcher.json.mockResolvedValue(mockResponse);
+        Fetcher.txt.mockResolvedValue(mockResponse);
+        Fetcher.markdown.mockResolvedValue(mockResponse);
+    });
+    test('fetchHtml 应该调用 Fetcher.html (fetchHtml should call Fetcher.html)', async () => {
+        // 调用方法
+        const result = await fetchHtml(testPayload);
+        // 验证 Fetcher.html 被调用
+        expect(Fetcher.html).toHaveBeenCalledWith(testPayload);
+        // 验证返回结果
+        expect(result).toBe(mockResponse);
+    });
+    test('fetchJson 应该调用 Fetcher.json (fetchJson should call Fetcher.json)', async () => {
+        // 调用方法
+        const result = await fetchJson(testPayload);
+        // 验证 Fetcher.json 被调用
+        expect(Fetcher.json).toHaveBeenCalledWith(testPayload);
+        // 验证返回结果
+        expect(result).toBe(mockResponse);
+    });
+    test('fetchTxt 应该调用 Fetcher.txt (fetchTxt should call Fetcher.txt)', async () => {
+        // 调用方法
+        const result = await fetchTxt(testPayload);
+        // 验证 Fetcher.txt 被调用
+        expect(Fetcher.txt).toHaveBeenCalledWith(testPayload);
+        // 验证返回结果
+        expect(result).toBe(mockResponse);
+    });
+    test('fetchMarkdown 应该调用 Fetcher.markdown (fetchMarkdown should call Fetcher.markdown)', async () => {
+        // 调用方法
+        const result = await fetchMarkdown(testPayload);
+        // 验证 Fetcher.markdown 被调用
+        expect(Fetcher.markdown).toHaveBeenCalledWith(testPayload);
+        // 验证返回结果
+        expect(result).toBe(mockResponse);
+    });
+});

package/dist/tests/fetchers/Fetcher.test.js

@@ -0,0 +1,108 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { describe, expect, test, beforeEach, vi } from 'vitest';
+import { Fetcher } from '../../src/lib/fetchers/index.js';
+import { FetcherFactory } from '../../src/lib/fetchers/FetcherFactory.js';
+import { log, COMPONENTS } from '../../src/lib/logger.js';
+// Mock FetcherFactory
+vi.mock('../../src/lib/fetchers/FetcherFactory.js', () => ({
+    FetcherFactory: {
+        createFetcher: vi.fn()
+    }
+}));
+// Mock logger
+vi.mock('../../src/lib/logger.js', () => ({
+    log: vi.fn(),
+    COMPONENTS: {
+        SERVER: 'SERVER'
+    }
+}));
+describe('Fetcher 类测试 (Fetcher Class Tests)', () => {
+    // 模拟 fetcher 实例
+    const mockFetcher = {
+        html: vi.fn(),
+        json: vi.fn(),
+        txt: vi.fn(),
+        markdown: vi.fn()
+    };
+    // 模拟响应
+    const mockResponse = {
+        content: [{ type: 'text', text: '测试内容' }],
+        isError: false
+    };
+    // 测试请求参数
+    const testPayload = {
+        url: 'https://example.com',
+        debug: true
+    };
+    beforeEach(() => {
+        // 重置所有 mock
+        vi.clearAllMocks();
+        // 设置 FetcherFactory.createFetcher 的返回值
+        FetcherFactory.createFetcher.mockReturnValue(mockFetcher);
+        // 设置 mockFetcher 方法的返回值
+        mockFetcher.html.mockResolvedValue(mockResponse);
+        mockFetcher.json.mockResolvedValue(mockResponse);
+        mockFetcher.txt.mockResolvedValue(mockResponse);
+        mockFetcher.markdown.mockResolvedValue(mockResponse);
+    });
+    test('应该正确获取HTML内容 (Should fetch HTML content correctly)', async () => {
+        // 调用方法
+        const result = await Fetcher.html(testPayload);
+        // 验证 FetcherFactory.createFetcher 被调用
+        expect(FetcherFactory.createFetcher).toHaveBeenCalledWith(testPayload);
+        // 验证 mockFetcher.html 被调用
+        expect(mockFetcher.html).toHaveBeenCalledWith(testPayload);
+        // 验证返回结果
+        expect(result).toBe(mockResponse);
+        // 验证日志被记录
+        expect(log).toHaveBeenCalledWith('fetcher.fetchingHtml', true, expect.objectContaining({
+            url: testPayload.url
+        }), COMPONENTS.SERVER);
+    });
+    test('应该正确获取JSON内容 (Should fetch JSON content correctly)', async () => {
+        // 调用方法
+        const result = await Fetcher.json(testPayload);
+        // 验证 FetcherFactory.createFetcher 被调用
+        expect(FetcherFactory.createFetcher).toHaveBeenCalledWith(testPayload);
+        // 验证 mockFetcher.json 被调用
+        expect(mockFetcher.json).toHaveBeenCalledWith(testPayload);
+        // 验证返回结果
+        expect(result).toBe(mockResponse);
+        // 验证日志被记录
+        expect(log).toHaveBeenCalledWith('fetcher.fetchingJson', true, expect.objectContaining({
+            url: testPayload.url
+        }), COMPONENTS.SERVER);
+    });
+    test('应该正确获取纯文本内容 (Should fetch plain text content correctly)', async () => {
+        // 调用方法
+        const result = await Fetcher.txt(testPayload);
+        // 验证 FetcherFactory.createFetcher 被调用
+        expect(FetcherFactory.createFetcher).toHaveBeenCalledWith(testPayload);
+        // 验证 mockFetcher.txt 被调用
+        expect(mockFetcher.txt).toHaveBeenCalledWith(testPayload);
+        // 验证返回结果
+        expect(result).toBe(mockResponse);
+        // 验证日志被记录
+        expect(log).toHaveBeenCalledWith('fetcher.fetchingTxt', true, expect.objectContaining({
+            url: testPayload.url
+        }), COMPONENTS.SERVER);
+    });
+    test('应该正确获取Markdown内容 (Should fetch Markdown content correctly)', async () => {
+        // 调用方法
+        const result = await Fetcher.markdown(testPayload);
+        // 验证 FetcherFactory.createFetcher 被调用
+        expect(FetcherFactory.createFetcher).toHaveBeenCalledWith(testPayload);
+        // 验证 mockFetcher.markdown 被调用
+        expect(mockFetcher.markdown).toHaveBeenCalledWith(testPayload);
+        // 验证返回结果
+        expect(result).toBe(mockResponse);
+        // 验证日志被记录
+        expect(log).toHaveBeenCalledWith('fetcher.fetchingMarkdown', true, expect.objectContaining({
+            url: testPayload.url
+        }), COMPONENTS.SERVER);
+    });
+});

package/dist/tests/fetchers/browser/BrowserFetcher.test.js

@@ -0,0 +1,195 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { BrowserFetcher } from '../../../src/lib/fetchers/browser/BrowserFetcher.js';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+// Mock Puppeteer
+vi.mock('puppeteer', () => {
+    return {
+        default: {
+            launch: vi.fn().mockResolvedValue({
+                newPage: vi.fn().mockResolvedValue({
+                    goto: vi.fn().mockResolvedValue({}),
+                    waitForSelector: vi.fn().mockResolvedValue({}),
+                    content: vi.fn().mockResolvedValue('<html><body>测试内容</body></html>'),
+                    evaluate: vi.fn(),
+                    close: vi.fn()
+                }),
+                close: vi.fn()
+            })
+        }
+    };
+});
+// Mock puppeteer-extra
+vi.mock('puppeteer-extra', () => {
+    return {
+        __esModule: true,
+        default: {
+            use: vi.fn().mockReturnThis(),
+            launch: vi.fn()
+        }
+    };
+});
+// Mock puppeteer-extra-plugin-stealth
+vi.mock('puppeteer-extra-plugin-stealth', () => {
+    return {
+        __esModule: true,
+        default: vi.fn().mockReturnValue({})
+    };
+});
+// Mock JSDOM
+vi.mock('jsdom', () => {
+    return {
+        JSDOM: class {
+            window;
+            constructor(html) {
+                this.window = {
+                    document: {
+                        body: {
+                            textContent: '这是纯文本内容'
+                        }
+                    }
+                };
+            }
+        }
+    };
+});
+// Mock TurndownService
+vi.mock('turndown', () => {
+    return {
+        default: class TurndownService {
+            constructor(options) { }
+            addRule(name, rule) { }
+            turndown(html) {
+                return '# 标题\n\n这是Markdown内容';
+            }
+        }
+    };
+});
+// Mock child_process
+vi.mock('child_process', () => {
+    return {
+        execSync: vi.fn().mockImplementation((cmd) => {
+            if (cmd.includes('http_proxy')) {
+                return 'http_proxy=http://proxy.example.com:8080';
+            }
+            return '';
+        })
+    };
+});
+// Mock logger
+vi.mock('../../../src/lib/logger.js', () => {
+    return {
+        log: vi.fn(),
+        COMPONENTS: {
+            BROWSER_FETCH: 'browser-fetch'
+        }
+    };
+});
+// Mock BrowserInstance
+vi.mock('../../../src/lib/fetchers/browser/BrowserInstance.js', () => {
+    return {
+        BrowserInstance: {
+            getInstance: vi.fn().mockResolvedValue({
+                newPage: vi.fn().mockResolvedValue({
+                    goto: vi.fn().mockResolvedValue({}),
+                    waitForSelector: vi.fn().mockResolvedValue({}),
+                    content: vi.fn().mockResolvedValue('<html><body>测试内容</body></html>'),
+                    evaluate: vi.fn(),
+                    close: vi.fn()
+                }),
+                close: vi.fn()
+            })
+        }
+    };
+});
+describe('BrowserFetcher 类测试 (BrowserFetcher Class Tests)', () => {
+    let browserFetcher;
+    let requestPayload;
+    beforeEach(() => {
+        // 创建BrowserFetcher实例 (Create BrowserFetcher instance)
+        browserFetcher = new BrowserFetcher();
+        // 重置模拟 (Reset mocks)
+        vi.clearAllMocks();
+        // 设置请求参数 (Set request parameters)
+        requestPayload = {
+            url: 'https://example.com',
+            headers: { 'User-Agent': 'test-agent' },
+            timeout: 5000,
+            waitForSelector: 'body',
+            waitForTimeout: 1000,
+            debug: true
+        };
+        // 模拟静态fetch方法 (Mock static fetch method)
+        vi.spyOn(BrowserFetcher, 'fetch').mockResolvedValue({
+            content: [{ type: 'text', text: '<html><body>测试内容</body></html>' }],
+            isError: false
+        });
+    });
+    describe('html 方法测试 (html Method Tests)', () => {
+        it('应该成功获取HTML内容 (should successfully fetch HTML content)', async () => {
+            // 调用方法 (Call method)
+            const result = await browserFetcher.html(requestPayload);
+            // 验证结果 (Verify result)
+            expect(result.isError).toBe(false);
+            expect(result.content[0].text).toBe('<html><body>测试内容</body></html>');
+        });
+        it('应该处理获取HTML时的错误 (should handle errors when fetching HTML)', async () => {
+            // 模拟错误 (Mock error)
+            vi.spyOn(BrowserFetcher, 'fetch').mockResolvedValue({
+                content: [{ type: 'text', text: 'Error fetching HTML: Error: 连接失败' }],
+                isError: true
+            });
+            // 调用方法 (Call method)
+            const result = await browserFetcher.html(requestPayload);
+            // 验证结果 (Verify result)
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain('连接失败');
+        });
+    });
+    describe('json 方法测试 (json Method Tests)', () => {
+        it('应该成功获取JSON内容 (should successfully fetch JSON content)', async () => {
+            // 模拟JSON内容 (Mock JSON content)
+            vi.spyOn(BrowserFetcher, 'fetch').mockResolvedValue({
+                content: [{ type: 'text', text: '{"name":"测试","value":123}' }],
+                isError: false
+            });
+            // 调用方法 (Call method)
+            const result = await browserFetcher.json(requestPayload);
+            // 验证结果 (Verify result)
+            expect(result.isError).toBe(false);
+            expect(result.content[0].text).toBe('{"name":"测试","value":123}');
+        });
+    });
+    describe('txt 方法测试 (txt Method Tests)', () => {
+        it('应该成功获取纯文本内容 (should successfully fetch plain text content)', async () => {
+            // 模拟HTML内容 (Mock HTML content)
+            vi.spyOn(BrowserFetcher, 'fetch').mockResolvedValue({
+                content: [{ type: 'text', text: '<html><body>这是纯文本内容</body></html>' }],
+                isError: false
+            });
+            // 调用方法 (Call method)
+            const result = await browserFetcher.txt(requestPayload);
+            // 验证结果 (Verify result)
+            expect(result.isError).toBe(false);
+            expect(result.content[0].text).toContain('这是纯文本内容');
+        });
+    });
+    describe('markdown 方法测试 (markdown Method Tests)', () => {
+        it('应该成功获取Markdown内容 (should successfully fetch Markdown content)', async () => {
+            // 模拟HTML内容 (Mock HTML content)
+            vi.spyOn(BrowserFetcher, 'fetch').mockResolvedValue({
+                content: [{ type: 'text', text: '<html><body><h1>标题</h1><p>这是Markdown内容</p></body></html>' }],
+                isError: false
+            });
+            // 调用方法 (Call method)
+            const result = await browserFetcher.markdown(requestPayload);
+            // 验证结果 (Verify result)
+            expect(result.isError).toBe(false);
+            expect(result.content[0].text).toContain('标题');
+            expect(result.content[0].text).toContain('这是Markdown内容');
+        });
+    });
+});