speed-test/test-connectivity.js

const SpeedTester = require('./src/core/speedTester');
const logger = require('./src/utils/logger');

// 测试节点配置 - 使用Clash混合端口7897
const testNodes = [
  // 测试直连（不使用代理）
  {
    id: 1,
    name: '直连测试',
    type: 'direct',
    server: '',
    port: 0,
    username: '',
    password: ''
  },
  // Clash混合端口HTTP代理
  {
    id: 2,
    name: '测试HTTP代理',
    type: 'http',
    server: '127.0.0.1',
    port: 7897,
    username: '',
    password: ''
  },
  // Clash混合端口SOCKS5代理
  {
    id: 3,
    name: '测试SOCKS5代理',
    type: 'socks5',
    server: '127.0.0.1',
    port: 7897,
    username: '',
    password: ''
  }
];

// 添加一个简单的直连测试函数
async function testDirectConnection() {
  console.log('🌐 测试直连连通性...');
  
  const axios = require('axios');
  const testUrls = [
    'https://www.google.com',
    'https://httpbin.org/get',
    'https://www.github.com'
  ];
  
  for (const url of testUrls) {
    try {
      console.log(`尝试连接: ${url}`);
      const startTime = Date.now();
      const response = await axios.get(url, {
        timeout: 10000,
        headers: {
          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
        }
      });
      const latency = Date.now() - startTime;
      
      console.log(`✅ 直连成功: ${url} (${latency}ms)`);
      console.log(`状态码: ${response.status}`);
      console.log(`IP: ${response.headers['x-forwarded-for'] || 'unknown'}`);
      return true;
    } catch (error) {
      console.log(`❌ 直连失败: ${url} - ${error.message}`);
    }
  }
  
  console.log('❌ 所有直连测试都失败了，请检查网络连接');
  return false;
}

async function testConnectivity() {
  console.log('🚀 开始连通性测试...\n');
  
  // 首先测试直连
  const directSuccess = await testDirectConnection();
  console.log('');
  
  if (!directSuccess) {
    console.log('⚠️  直连测试失败，代理测试可能也会失败');
    console.log('请检查网络连接或防火墙设置\n');
  }
  
  const speedTester = new SpeedTester();
  
  try {
    // 测试单个节点
    console.log('📡 测试代理节点...');
    const singleResult = await speedTester.testNode(testNodes[1]); // 测试HTTP代理
    console.log('单个节点测试结果:', JSON.stringify(singleResult, null, 2));
    console.log('');
    
    // 批量测试节点
    console.log('📡 批量测试节点...');
    const batchResults = await speedTester.testNodes(testNodes.slice(1)); // 跳过直连测试
    
    console.log('\n📊 测试结果汇总:');
    console.log('='.repeat(50));
    
    batchResults.forEach((result, index) => {
      const node = testNodes[index + 1]; // +1 因为跳过了直连测试
      const status = result.isSuccess ? '✅ 连通' : '❌ 不通';
      const latency = result.latency ? `${result.latency}ms` : 'N/A';
      const ip = result.ipAddress || 'N/A';
      
      console.log(`${status} ${node.name} (${node.type})`);
      console.log(`   延迟: ${latency}`);
      console.log(`   IP: ${ip}`);
      console.log(`   测试URL: ${result.testUrl || 'N/A'}`);
      if (result.errorMessage) {
        console.log(`   错误: ${result.errorMessage}`);
      }
      console.log('');
    });
    
    const successCount = batchResults.filter(r => r.isSuccess).length;
    console.log(`总计: ${successCount}/${batchResults.length} 个节点连通`);
    
    // 提供故障排除建议
    if (successCount === 0) {
      console.log('\n🔧 故障排除建议:');
      console.log('1. 检查代理服务是否正在运行');
      console.log('2. 确认代理端口是否正确');
      console.log('3. 检查防火墙设置');
      console.log('4. 尝试使用其他代理服务器');
      console.log('5. 检查代理配置是否正确');
    }
    
  } catch (error) {
    console.error('❌ 测试过程中发生错误:', error.message);
  }
}

// 添加一个简单的代理检测函数
async function detectLocalProxies() {
  console.log('🔍 检测本地代理服务...');
  
  const net = require('net');
  const commonPorts = [7897, 7891, 8118, 3128, 8388, 10808];
  
  for (const port of commonPorts) {
    try {
      const socket = new net.Socket();
      const result = await new Promise((resolve) => {
        socket.setTimeout(2000);
        socket.on('connect', () => {
          socket.destroy();
          resolve(true);
        });
        socket.on('timeout', () => {
          socket.destroy();
          resolve(false);
        });
        socket.on('error', () => {
          socket.destroy();
          resolve(false);
        });
        socket.connect(port, '127.0.0.1');
      });
      
      if (result) {
        console.log(`✅ 发现本地代理服务: 127.0.0.1:${port}`);
      }
    } catch (error) {
      // 忽略错误
    }
  }
  
  console.log('检测完成\n');
}

// 如果直接运行此脚本
if (require.main === module) {
  // 先检测本地代理
  detectLocalProxies().then(() => {
    return testConnectivity();
  }).catch(console.error);
}

module.exports = { testConnectivity, testDirectConnection, detectLocalProxies };