@becrafter/prompt-manager 0.1.17 → 0.1.20

package/packages/server/tests/unit/WebSocketService.test.js

@@ -1,403 +0,0 @@
-/**
- * WebSocketService 单元测试
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-
-// Mock all modules before imports
-vi.mock('ws', () => ({
-  WebSocketServer: vi.fn(),
-  WebSocket: vi.fn()
-}));
-
-vi.mock('../../utils/logger.js', () => ({
-  logger: {
-    info: vi.fn(),
-    error: vi.fn(),
-    debug: vi.fn(),
-    warn: vi.fn()
-  }
-}));
-
-vi.mock('../../services/TerminalService.js', () => ({
-  terminalService: {
-    createSession: vi.fn(),
-    getSession: vi.fn(),
-    removeSession: vi.fn()
-  }
-}));
-
-// Now import the modules
-import { WebSocketService, WebSocketConnection } from '../../services/WebSocketService.js';
-import { terminalService } from '../../services/TerminalService.js';
-import { WebSocketServer } from 'ws';
-
-describe('WebSocketService', () => {
-  let webSocketService;
-  let mockWss;
-  let mockWs;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    // Mock WebSocket Server
-    mockWss = {
-      on: vi.fn(),
-      close: vi.fn()
-    };
-    WebSocketServer.mockImplementation(() => mockWss);
-
-    // Mock WebSocket
-    mockWs = {
-      readyState: 1, // WebSocket.OPEN
-      OPEN: 1,
-      send: vi.fn(),
-      close: vi.fn(),
-      ping: vi.fn(),
-      on: vi.fn()
-    };
-
-    // 创建服务实例
-    webSocketService = new WebSocketService({
-      port: 8081,
-      maxConnections: 5
-    });
-  });
-
-  afterEach(async () => {
-    if (webSocketService) {
-      // 清理连接以避免 close 方法错误
-      webSocketService.connections.clear();
-      try {
-        await webSocketService.stop();
-      } catch (error) {
-        // 忽略清理时的错误
-      }
-    }
-  });
-
-  describe('constructor', () => {
-    it('应该使用默认选项初始化', () => {
-      const service = new WebSocketService();
-      expect(service.options.port).toBe(8081);
-      expect(service.options.maxConnections).toBe(100);
-      expect(service.connections.size).toBe(0);
-      expect(service.isRunning).toBe(false);
-    });
-
-    it('应该使用自定义选项初始化', () => {
-      const customOptions = {
-        port: 9090,
-        maxConnections: 50,
-        heartbeatInterval: 60000
-      };
-      const service = new WebSocketService(customOptions);
-      expect(service.options.port).toBe(9090);
-      expect(service.options.maxConnections).toBe(50);
-      expect(service.options.heartbeatInterval).toBe(60000);
-    });
-  });
-
-  describe('start', () => {
-    it('应该成功启动WebSocket服务', async () => {
-      // 模拟服务器启动成功
-      let listeningCallback;
-      mockWss.on.mockImplementation((event, callback) => {
-        if (event === 'listening') {
-          listeningCallback = callback;
-        }
-      });
-
-      const startPromise = webSocketService.start();
-      
-      // 触发listening事件
-      listeningCallback();
-      
-      await startPromise;
-      
-      expect(webSocketService.isRunning).toBe(true);
-      expect(WebSocketServer).toHaveBeenCalledWith({
-        port: 8081,
-        host: '0.0.0.0',
-        maxConnections: 5
-      });
-      expect(mockWss.on).toHaveBeenCalledWith('connection', expect.any(Function));
-      expect(mockWss.on).toHaveBeenCalledWith('error', expect.any(Function));
-      expect(mockWss.on).toHaveBeenCalledWith('listening', expect.any(Function));
-    });
-
-    it('应该在已经运行时抛出错误', async () => {
-      webSocketService.isRunning = true;
-      
-      await expect(webSocketService.start()).rejects.toThrow('WebSocket service is already running');
-    });
-
-    it('应该在服务器错误时抛出错误', async () => {
-      const error = new Error('Server error');
-      mockWss.on.mockImplementation((event, callback) => {
-        if (event === 'error') {
-          callback(error);
-        }
-      });
-
-      await expect(webSocketService.start()).rejects.toThrow('Server error');
-    });
-  });
-
-  describe('stop', () => {
-    it('应该成功停止WebSocket服务', async () => {
-      // 设置为运行状态
-      webSocketService.isRunning = true;
-      webSocketService.wss = mockWss;
-
-      // 添加一个连接
-      const mockConnection = {
-        close: vi.fn(),
-        ws: { readyState: 1 }
-      };
-      webSocketService.connections.set('test-client', mockConnection);
-
-      await webSocketService.stop();
-
-      expect(webSocketService.isRunning).toBe(false);
-      expect(mockConnection.close).toHaveBeenCalledWith(1001, 'Server shutdown');
-      expect(mockWss.close).toHaveBeenCalled();
-    });
-
-    it('应该在未运行时不执行任何操作', async () => {
-      webSocketService.isRunning = false;
-      
-      await webSocketService.stop();
-      
-      expect(mockWss.close).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('handleConnection', () => {
-    beforeEach(() => {
-      webSocketService.isRunning = true;
-      webSocketService.wss = mockWss;
-    });
-
-    it('应该处理新的连接', () => {
-      const mockRequest = {
-        socket: {
-          remoteAddress: '127.0.0.1'
-        }
-      };
-
-      // 确保 mockWs 有正确的 readyState
-      mockWs.readyState = 1;
-      mockWs.OPEN = 1;
-
-      webSocketService.handleConnection(mockWs, mockRequest);
-
-      expect(webSocketService.connections.size).toBe(1);
-      expect(mockWs.send).toHaveBeenCalledWith(
-        expect.stringContaining('"type":"welcome"')
-      );
-    });
-
-    it('应该在超过最大连接数时拒绝连接', () => {
-      // 添加最大数量的连接
-      for (let i = 0; i < 5; i++) {
-        webSocketService.connections.set(`client-${i}`, {});
-      }
-
-      webSocketService.handleConnection(mockWs, {});
-      
-      expect(mockWs.close).toHaveBeenCalledWith(1013, 'Server overload');
-      expect(webSocketService.connections.size).toBe(5);
-    });
-  });
-
-  describe('broadcast', () => {
-    beforeEach(() => {
-      // 添加模拟连接
-      const connection1 = { 
-        send: vi.fn(),
-        ws: { readyState: 1, OPEN: 1 }
-      };
-      const connection2 = { 
-        send: vi.fn(),
-        ws: { readyState: 1, OPEN: 1 }
-      };
-      
-      webSocketService.connections.set('client1', connection1);
-      webSocketService.connections.set('client2', connection2);
-    });
-
-    it('应该向所有连接广播消息', () => {
-      const message = { type: 'test', data: 'broadcast data' };
-      
-      webSocketService.broadcast('test', { data: 'broadcast data' });
-      
-      const connections = Array.from(webSocketService.connections.values());
-      expect(connections[0].send).toHaveBeenCalledWith('test', { data: 'broadcast data' });
-      expect(connections[1].send).toHaveBeenCalledWith('test', { data: 'broadcast data' });
-    });
-  });
-
-  describe('getStatus', () => {
-    it('应该返回正确的服务状态', () => {
-      webSocketService.isRunning = true;
-      webSocketService.options.port = 8081;
-      webSocketService.options.host = '0.0.0.0';
-      webSocketService.options.maxConnections = 5;
-
-      // 添加一个活跃连接
-      const activeConnection = { 
-        ws: { readyState: 1, OPEN: 1 } // WebSocket.OPEN
-      };
-      webSocketService.connections.set('active', activeConnection);
-
-      const status = webSocketService.getStatus();
-
-      expect(status).toHaveProperty('isRunning', true);
-      expect(status).toHaveProperty('port', 8081);
-      expect(status).toHaveProperty('host', '0.0.0.0');
-      expect(status).toHaveProperty('totalConnections', 1);
-      expect(status).toHaveProperty('activeConnections', 1);
-      expect(status).toHaveProperty('maxConnections', 5);
-      expect(status).toHaveProperty('uptime');
-    });
-  });
-});
-
-describe('WebSocketConnection', () => {
-  let connection;
-  let mockWs;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    mockWs = {
-      readyState: 1, // WebSocket.OPEN
-      OPEN: 1,
-      send: vi.fn(),
-      close: vi.fn(),
-      ping: vi.fn(),
-      on: vi.fn()
-    };
-
-    // 清理之前的 mock 调用记录
-    terminalService.createSession.mockClear();
-    terminalService.getSession.mockClear();
-    terminalService.removeSession.mockClear();
-
-    // 创建连接实例
-    connection = new WebSocketConnection(mockWs, 'test-client');
-  });
-
-  describe('constructor', () => {
-    it('应该正确初始化连接', () => {
-      expect(connection.clientId).toBe('test-client');
-      expect(connection.ws).toBe(mockWs);
-      expect(connection.isAuthenticated).toBe(false);
-      expect(connection.sessionId).toBeNull();
-      expect(mockWs.on).toHaveBeenCalledWith('message', expect.any(Function));
-      expect(mockWs.on).toHaveBeenCalledWith('close', expect.any(Function));
-      expect(mockWs.on).toHaveBeenCalledWith('error', expect.any(Function));
-      expect(mockWs.on).toHaveBeenCalledWith('pong', expect.any(Function));
-    });
-  });
-
-  describe.skip('handleMessage', () => {
-    // 这些测试需要更深入的 mock 重构，暂时跳过
-    it.skip('应该处理终端创建消息', async () => {
-      // TODO: 修复 terminalService mock 交互问题
-    });
-
-    it.skip('应该处理终端数据消息', async () => {
-      // TODO: 修复 terminalService mock 交互问题
-    });
-
-    it.skip('应该处理终端调整大小消息', async () => {
-      // TODO: 修复 terminalService mock 交互问题
-    });
-
-    it('应该处理ping消息', () => {
-      const message = { type: 'ping' };
-
-      const messageHandler = mockWs.on.mock.calls.find(call => call[0] === 'message')[1];
-      messageHandler(JSON.stringify(message));
-
-      expect(mockWs.send).toHaveBeenCalledWith(
-        expect.stringContaining('"type":"pong"')
-      );
-    });
-
-    it('应该处理未知消息类型', () => {
-      const message = { type: 'unknown' };
-
-      const messageHandler = mockWs.on.mock.calls.find(call => call[0] === 'message')[1];
-      messageHandler(JSON.stringify(message));
-
-      expect(mockWs.send).toHaveBeenCalledWith(
-        expect.stringContaining('"type":"error"')
-      );
-    });
-  });
-
-  describe('send', () => {
-    it('应该发送消息', () => {
-      const data = { test: 'data' };
-      
-      connection.send('test', data);
-
-      // 检查 mockWs.send 被调用，并验证调用参数包含正确的 JSON 结构
-      expect(mockWs.send).toHaveBeenCalledTimes(1);
-      const sentMessage = JSON.parse(mockWs.send.mock.calls[0][0]);
-      
-      expect(sentMessage.type).toBe('test');
-      expect(sentMessage.clientId).toBe('test-client');
-      expect(sentMessage.test).toBe('data');
-      expect(typeof sentMessage.timestamp).toBe('number');
-    });
-
-    it('应该在连接未打开时不发送消息', () => {
-      mockWs.readyState = 0; // WebSocket.CONNECTING
-      
-      connection.send('test', { data: 'test' });
-      
-      expect(mockWs.send).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('sendError', () => {
-    it('应该发送错误消息', () => {
-      connection.sendError('Test error', 'Error details');
-
-      // 检查 mockWs.send 被调用，并验证调用参数包含正确的 JSON 结构
-      expect(mockWs.send).toHaveBeenCalledTimes(1);
-      const sentMessage = JSON.parse(mockWs.send.mock.calls[0][0]);
-      
-      expect(sentMessage.type).toBe('error');
-      expect(sentMessage.clientId).toBe('test-client');
-      expect(sentMessage.message).toBe('Test error');
-      expect(sentMessage.details).toBe('Error details');
-      expect(typeof sentMessage.timestamp).toBe('number');
-    });
-  });
-
-  describe('getInfo', () => {
-    it('应该返回连接信息', () => {
-      const info = connection.getInfo();
-
-      expect(info).toHaveProperty('clientId', 'test-client');
-      expect(info).toHaveProperty('connectedAt');
-      expect(info).toHaveProperty('lastActivity');
-      expect(info).toHaveProperty('sessionId', null);
-      expect(info).toHaveProperty('isAuthenticated', false);
-      expect(info).toHaveProperty('readyState', mockWs.readyState);
-    });
-  });
-
-  describe('close', () => {
-    it('应该关闭连接', () => {
-      connection.close(1000, 'Test close');
-
-      expect(mockWs.close).toHaveBeenCalledWith(1000, 'Test close');
-    });
-  });
-});

package/packages/server/tests/unit/core.test.js

@@ -1,94 +0,0 @@
-/**
- * 核心库功能测试
- * 测试库是否能正确导入和使用
- */
-
-import { describe, it, expect, beforeAll } from 'vitest';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// 获取server包的index.js路径
-const serverIndexPath = path.join(__dirname, '../../index.js');
-
-describe('核心库导入测试', () => {
-  let coreModules = {};
-
-  beforeAll(async () => {
-    // 动态导入所有导出的函数和对象
-    coreModules = await import(serverIndexPath);
-  });
-
-  it('应该成功导入所有模块', () => {
-    expect(coreModules).toBeDefined();
-    expect(Object.keys(coreModules).length).toBeGreaterThan(0);
-  });
-
-  it('应该导出服务器相关函数', () => {
-    expect(typeof coreModules.startServer).toBe('function');
-    expect(typeof coreModules.stopServer).toBe('function');
-    expect(typeof coreModules.getServerState).toBe('function');
-    expect(typeof coreModules.getServerAddress).toBe('function');
-    expect(typeof coreModules.isServerRunning).toBe('function');
-  });
-
-  it('应该导出核心对象', () => {
-    expect(typeof coreModules.app).toBe('function');
-    expect(typeof coreModules.config).toBe('object');
-    expect(typeof coreModules.logger).toBe('object');
-    expect(typeof coreModules.util).toBe('object');
-    expect(typeof coreModules.promptManager).toBe('object');
-  });
-
-  it('应该导出MCP相关函数', () => {
-    expect(typeof coreModules.getMcpServer).toBe('function');
-    expect(typeof coreModules.handleGetPrompt).toBe('function');
-    expect(typeof coreModules.handleSearchPrompts).toBe('function');
-    expect(typeof coreModules.handleReloadPrompts).toBe('function');
-  });
-
-  it('应该导出路由相关对象', () => {
-    expect(typeof coreModules.adminRouter).toBe('function');
-    expect(typeof coreModules.openRouter).toBe('function');
-    expect(typeof coreModules.adminAuthMiddleware).toBe('function');
-  });
-
-  it('配置对象应该有正确的方法', () => {
-    expect(typeof coreModules.config.getPort).toBe('function');
-    expect(typeof coreModules.config.getPromptsDir).toBe('function');
-  });
-
-  it('日志对象应该有正确的方法', () => {
-    expect(typeof coreModules.logger.info).toBe('function');
-    expect(typeof coreModules.logger.error).toBe('function');
-    expect(typeof coreModules.logger.warn).toBe('function');
-    expect(typeof coreModules.logger.debug).toBe('function');
-  });
-
-  it('工具对象应该正确导出', () => {
-    expect(coreModules.util).toBeDefined();
-    expect(typeof coreModules.util).toBe('object');
-  });
-
-  it('提示词管理器应该正确导出', () => {
-    expect(coreModules.promptManager).toBeDefined();
-    expect(typeof coreModules.promptManager).toBe('object');
-  });
-
-  it('服务器状态函数应该正常工作', async () => {
-    expect(typeof coreModules.getServerAddress).toBe('function');
-    expect(typeof coreModules.isServerRunning).toBe('function');
-    
-    // 测试函数调用
-    const state = coreModules.getServerState();
-    expect(typeof state).toBe('object');
-    
-    const address = coreModules.getServerAddress();
-    expect(typeof address).toBe('string');
-    
-    const isRunning = await coreModules.isServerRunning();
-    expect(typeof isRunning).toBe('boolean');
-  });
-});

package/packages/server/typedoc.json

@@ -1,52 +0,0 @@
-{
-  "entryPoints": [
-    "./index.js",
-    "./services/",
-    "./utils/",
-    "./mcp/",
-    "./api/",
-    "./toolm/"
-  ],
-  "out": "./docs/typedoc/",
-  "exclude": [
-    "node_modules/",
-    "dist/",
-    "coverage/",
-    "tests/",
-    "test-results/",
-    "**/*.test.js",
-    "**/*.spec.js"
-  ],
-  "excludePrivate": true,
-  "excludeProtected": false,
-  "excludeInternal": true,
-  "hideGenerator": true,
-  "sort": ["source-order"],
-  "kindSortOrder": [
-    "Class",
-    "Interface",
-    "Type alias",
-    "Variable",
-    "Function",
-    "Enum",
-    "Namespace"
-  ],
-  "categorizeByGroup": true,
-  "defaultCategory": "Other",
-  "categoryOrder": [
-    "Services",
-    "Utils",
-    "MCP",
-    "API",
-    "Tools",
-    "*"
-  ],
-  "plugin": [
-    "typedoc-plugin-markdown",
-    "typedoc-plugin-mermaid"
-  ],
-  "readme": "none",
-  "gitRevision": "main",
-  "sourceLinkTemplate": "https://github.com/BeCrafter/prompt-manager/blob/{gitRevision}/{path}#L{line}",
-  "tsconfig": "./tsconfig.json"
-}

package/packages/server/vitest.config.js

@@ -1,74 +0,0 @@
-/**
- * Vitest 配置文件
- */
-
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    // 测试环境
-    environment: 'node',
-    
-    // 全局配置
-    globals: true,
-    
-    // 设置文件
-    setupFiles: ['./tests/setup.js'],
-    
-    // 测试文件匹配模式
-    include: [
-      'tests/**/*.test.js',
-      'tests/**/*.spec.js'
-    ],
-    
-    // 排除文件
-    exclude: [
-      'node_modules',
-      'dist',
-      'tests/e2e/**'
-    ],
-    
-    // 覆盖率配置
-    coverage: {
-      provider: 'v8',
-      reporter: ['text', 'json', 'html'],
-      exclude: [
-        'node_modules',
-        'dist',
-        'tests',
-        '**/*.test.js',
-        '**/*.spec.js'
-      ],
-      thresholds: {
-        global: {
-          branches: 70,
-          functions: 70,
-          lines: 70,
-          statements: 70
-        }
-      }
-    },
-    
-    // 测试超时
-    testTimeout: 10000,
-    
-    // 钩子超时
-    hookTimeout: 10000,
-    
-    // 并发测试
-    threads: true,
-    
-    // 监听模式配置
-    watch: false,
-    
-    // 报告器
-    reporter: ['verbose', 'html']
-  },
-  
-  // 解析配置
-  resolve: {
-    alias: {
-      '@': '/Users/mark/code/GitHub/BeCrafter/prompt-manager/packages/server'
-    }
-  }
-});