Mini-Program/server-example/test_complete_chat_flow.js

const WebSocket = require('ws');
const crypto = require('crypto');

// 配置信息
const SERVER_URL = 'ws://localhost:3003'; // 修改为正确的端口
const USER_ID = 'test_user_1';
const MANAGER_ID = '22';

// 测试消息内容
const TEST_MESSAGE = '这是一条测试消息，验证聊天功能是否正常工作！';

// 跟踪测试状态
let testResults = {
  userConnected: false,
  managerConnected: false,
  userAuthenticated: false,
  managerAuthenticated: false,
  messageSent: false,
  messageReceivedByManager: false,
  messageStoredInDatabase: false,
  error: null
};

// 用户连接
let userWs;
// 客服连接
let managerWs;

// 开始测试
console.log('开始测试完整的聊天功能流程...');

// 连接客服
function connectManager() {
  return new Promise((resolve, reject) => {
    console.log(`\n正在连接客服 (managerId: ${MANAGER_ID})...`);
    managerWs = new WebSocket(SERVER_URL);
    
    managerWs.on('open', () => {
      console.log('✅ 客服WebSocket连接已建立');
      testResults.managerConnected = true;
      
      // 客服认证
      console.log('客服发送认证请求...');
      const authMessage = {
        type: 'auth',
        managerId: MANAGER_ID,
        userType: 'manager'
      };
      managerWs.send(JSON.stringify(authMessage));
    });
    
    managerWs.on('message', (data) => {
      try {
        const message = JSON.parse(data.toString());
        console.log('👂 客服收到消息:', JSON.stringify(message));
        
        // 处理认证响应
        if (message.type === 'auth_success' && !testResults.managerAuthenticated) {
          console.log('✅ 客服认证成功');
          testResults.managerAuthenticated = true;
          resolve();
        }
        
        // 处理心跳响应
        if (message.type === 'pong') {
          console.log('⏱️  客服收到心跳响应');
        }
        
        // 处理新消息
        if (message.type === 'new_message' && message.payload) {
          console.log('📩 客服收到新消息:', message.payload.content);
          if (message.payload.content === TEST_MESSAGE) {
            testResults.messageReceivedByManager = true;
            console.log('✅ 测试成功: 客服收到了用户发送的消息！');
            completeTest();
          }
        }
        
        // 处理错误
        if (message.type === 'error') {
          console.error('❌ 客服收到错误:', message.message);
          testResults.error = message.message;
          reject(new Error(message.message));
        }
      } catch (error) {
        console.error('❌ 客服消息解析错误:', error);
        testResults.error = error.message;
        reject(error);
      }
    });
    
    managerWs.on('error', (error) => {
      console.error('❌ 客服WebSocket连接错误:', error);
      testResults.error = error.message;
      reject(error);
    });
    
    managerWs.on('close', () => {
      console.log('❌ 客服WebSocket连接已关闭');
      testResults.managerConnected = false;
    });
  });
}

// 连接用户
function connectUser() {
  return new Promise((resolve, reject) => {
    console.log(`\n正在连接用户 (userId: ${USER_ID})...`);
    userWs = new WebSocket(SERVER_URL);
    
    userWs.on('open', () => {
      console.log('✅ 用户WebSocket连接已建立');
      testResults.userConnected = true;
      
      // 用户认证
      console.log('用户发送认证请求...');
      const authMessage = {
        type: 'auth',
        userId: USER_ID,
        userType: 'user'
      };
      userWs.send(JSON.stringify(authMessage));
    });
    
    userWs.on('message', (data) => {
      try {
        const message = JSON.parse(data.toString());
        console.log('👂 用户收到消息:', JSON.stringify(message));
        
        // 处理认证响应
        if (message.type === 'auth_success' && !testResults.userAuthenticated) {
          console.log('✅ 用户认证成功');
          testResults.userAuthenticated = true;
          resolve();
        }
        
        // 处理心跳响应
        if (message.type === 'pong') {
          console.log('⏱️  用户收到心跳响应');
        }
        
        // 处理消息发送确认
        if (message.type === 'message_sent') {
          console.log('✅ 用户消息发送确认:', message.payload);
          testResults.messageSent = true;
          // 消息发送成功后，等待客服接收
          setTimeout(() => {
            if (!testResults.messageReceivedByManager) {
              console.error('❌ 测试失败: 客服未收到用户消息');
              completeTest();
            }
          }, 5000); // 等待5秒查看客服是否收到消息
        }
        
        // 处理错误
        if (message.type === 'error') {
          console.error('❌ 用户收到错误:', message.message);
          testResults.error = message.message;
          reject(new Error(message.message));
        }
      } catch (error) {
        console.error('❌ 用户消息解析错误:', error);
        testResults.error = error.message;
        reject(error);
      }
    });
    
    userWs.on('error', (error) => {
      console.error('❌ 用户WebSocket连接错误:', error);
      testResults.error = error.message;
      reject(error);
    });
    
    userWs.on('close', () => {
      console.log('❌ 用户WebSocket连接已关闭');
      testResults.userConnected = false;
    });
  });
}

// 发送测试消息
function sendTestMessage() {
  return new Promise((resolve) => {
    setTimeout(() => {
      console.log(`\n正在发送测试消息给客服...`);
      const messageId = crypto.randomUUID();
      const message = {
        type: 'chat_message', // 确保使用正确的消息类型
        data: {
          messageId: messageId,
          userId: USER_ID,
          managerId: MANAGER_ID,
          content: TEST_MESSAGE,
          contentType: 1, // 文本消息
          timestamp: Date.now()
        }
      };
      
      console.log('发送消息:', JSON.stringify(message));
      userWs.send(JSON.stringify(message));
      resolve();
    }, 1000);
  });
}

// 清理连接
function cleanup() {
  if (userWs && userWs.readyState === WebSocket.OPEN) {
    userWs.close();
  }
  if (managerWs && managerWs.readyState === WebSocket.OPEN) {
    managerWs.close();
  }
}

// 完成测试并输出结果
function completeTest() {
  console.log('\n📊 测试结果摘要:');
  console.log('- 用户连接成功:', testResults.userConnected);
  console.log('- 客服连接成功:', testResults.managerConnected);
  console.log('- 用户认证成功:', testResults.userAuthenticated);
  console.log('- 客服认证成功:', testResults.managerAuthenticated);
  console.log('- 消息发送成功:', testResults.messageSent);
  console.log('- 客服收到消息:', testResults.messageReceivedByManager);
  
  if (testResults.error) {
    console.log('\n❌ 测试失败: ' + testResults.error);
  } else if (testResults.messageReceivedByManager) {
    console.log('\n🎉 测试成功! 聊天功能正常工作!');
  } else {
    console.log('\n❌ 测试失败: 聊天功能存在问题');
  }
  
  // 清理并退出
  cleanup();
  setTimeout(() => {
    process.exit(testResults.messageReceivedByManager ? 0 : 1);
  }, 1000);
}

// 主测试流程
async function runTest() {
  try {
    // 1. 先连接客服
    await connectManager();
    console.log('客服连接和认证成功');
    
    // 2. 再连接用户
    await connectUser();
    console.log('用户连接和认证成功');
    
    // 3. 发送测试消息
    await sendTestMessage();
    console.log('测试消息已发送');
    
    // 4. 设置超时
    setTimeout(() => {
      if (!testResults.messageReceivedByManager) {
        console.error('❌ 测试超时: 客服在规定时间内未收到消息');
        completeTest();
      }
    }, 10000);
    
  } catch (error) {
    console.error('❌ 测试执行失败:', error);
    testResults.error = error.message;
    completeTest();
  }
}

// 运行测试
runTest();

// 监听进程退出
process.on('SIGINT', () => {
  console.log('\n正在中断测试...');
  cleanup();
  process.exit(1);
});