module4_backend_project/tests/load-test.js

const autocannon = require('autocannon');
const { performance } = require('perf_hooks');

class LoadTester {
  constructor() {
    this.baseUrl = process.env.TEST_URL || 'http://localhost:3049';
    this.results = [];
  }

  async runPurchaseLoadTest(eventId = 1, options = {}) {
    const defaultOptions = {
      url: `${this.baseUrl}/buy/${eventId}`,
      connections: 5000,
      duration: 30,
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({}),
      ...options
    };

    console.log(`\n🚀 Starting load test for Event ${eventId}`);
    console.log(`📊 Connections: ${defaultOptions.connections}`);
    console.log(`⏱️  Duration: ${defaultOptions.duration}s`);
    console.log(`🎯 Target: ${defaultOptions.url}\n`);

    const startTime = performance.now();

    try {
      const result = await autocannon(defaultOptions);
      const endTime = performance.now();
      
      const testResult = {
        eventId,
        timestamp: new Date().toISOString(),
        duration: endTime - startTime,
        ...result
      };

      this.results.push(testResult);
      this.printResults(testResult);
      
      return testResult;
    } catch (error) {
      console.error('❌ Load test failed:', error);
      throw error;
    }
  }

  async runMultiEventLoadTest(eventIds = [1, 2, 3], options = {}) {
    console.log(`\n🎯 Running multi-event load test for events: ${eventIds.join(', ')}`);
    
    const promises = eventIds.map(eventId => 
      this.runPurchaseLoadTest(eventId, {
        connections: Math.floor((options.connections || 5000) / eventIds.length),
        duration: options.duration || 30
      })
    );

    try {
      const results = await Promise.all(promises);
      this.printSummary(results);
      return results;
    } catch (error) {
      console.error('❌ Multi-event load test failed:', error);
      throw error;
    }
  }

  async runHealthCheckTest(options = {}) {
    const defaultOptions = {
      url: `${this.baseUrl}/health`,
      connections: 100,
      duration: 10,
      ...options
    };

    console.log('\n🏥 Running health check load test...');
    
    try {
      const result = await autocannon(defaultOptions);
      console.log(`✅ Health check test completed`);
      console.log(`📈 RPS: ${result.requests.average}`);
      console.log(`⚡ Latency: ${result.latency.average}ms`);
      
      return result;
    } catch (error) {
      console.error('❌ Health check test failed:', error);
      throw error;
    }
  }

  async runMetricsTest(options = {}) {
    const defaultOptions = {
      url: `${this.baseUrl}/metrics`,
      connections: 50,
      duration: 10,
      ...options
    };

    console.log('\n📊 Running metrics endpoint test...');
    
    try {
      const result = await autocannon(defaultOptions);
      console.log(`✅ Metrics test completed`);
      console.log(`📈 RPS: ${result.requests.average}`);
      console.log(`⚡ Latency: ${result.latency.average}ms`);
      
      return result;
    } catch (error) {
      console.error('❌ Metrics test failed:', error);
      throw error;
    }
  }

  printResults(result) {
    console.log('📋 LOAD TEST RESULTS');
    console.log('═'.repeat(50));
    console.log(`🎯 Event ID: ${result.eventId}`);
    console.log(`⏱️  Duration: ${(result.duration / 1000).toFixed(2)}s`);
    console.log(`📊 Total Requests: ${result.requests.total}`);
    console.log(`📈 Requests/sec: ${result.requests.average.toFixed(2)}`);
    console.log(`⚡ Avg Latency: ${result.latency.average.toFixed(2)}ms`);
    console.log(`🔥 Max Latency: ${result.latency.max}ms`);
    console.log(`✅ Success Rate: ${((result.requests.total - result.non2xx) / result.requests.total * 100).toFixed(2)}%`);
    console.log(`❌ Errors: ${result.non2xx}`);
    console.log(`🔗 Connections: ${result.connections}`);
    console.log(`📦 Throughput: ${(result.throughput.average / 1024 / 1024).toFixed(2)} MB/s`);
    console.log('═'.repeat(50));
  }

  printSummary(results) {
    console.log('\n📊 MULTI-EVENT TEST SUMMARY');
    console.log('═'.repeat(60));
    
    const totalRequests = results.reduce((sum, r) => sum + r.requests.total, 0);
    const avgRPS = results.reduce((sum, r) => sum + r.requests.average, 0);
    const avgLatency = results.reduce((sum, r) => sum + r.latency.average, 0) / results.length;
    const totalErrors = results.reduce((sum, r) => sum + r.non2xx, 0);
    
    console.log(`🎯 Events Tested: ${results.length}`);
    console.log(`📊 Total Requests: ${totalRequests}`);
    console.log(`📈 Combined RPS: ${avgRPS.toFixed(2)}`);
    console.log(`⚡ Avg Latency: ${avgLatency.toFixed(2)}ms`);
    console.log(`✅ Overall Success Rate: ${((totalRequests - totalErrors) / totalRequests * 100).toFixed(2)}%`);
    console.log(`❌ Total Errors: ${totalErrors}`);
    console.log('═'.repeat(60));
    
    // Individual event breakdown
    results.forEach((result, index) => {
      console.log(`\n📋 Event ${result.eventId}:`);
      console.log(`  📈 RPS: ${result.requests.average.toFixed(2)}`);
      console.log(`  ⚡ Latency: ${result.latency.average.toFixed(2)}ms`);
      console.log(`  ✅ Success: ${((result.requests.total - result.non2xx) / result.requests.total * 100).toFixed(2)}%`);
    });
  }

  async runFullTestSuite() {
    console.log('🚀 STARTING FULL LOAD TEST SUITE');
    console.log('═'.repeat(60));
    
    try {
      // 1. Health check test
      await this.runHealthCheckTest();
      
      // 2. Metrics test
      await this.runMetricsTest();
      
      // 3. Single event high-load test
      await this.runPurchaseLoadTest(1, { 
        connections: 5000, 
        duration: 30 
      });
      
      // 4. Multi-event test
      await this.runMultiEventLoadTest([1, 2, 3], {
        connections: 6000,
        duration: 30
      });
      
      console.log('\n🎉 FULL TEST SUITE COMPLETED!');
      console.log(`📊 Total tests run: ${this.results.length + 2}`);
      
    } catch (error) {
      console.error('❌ Test suite failed:', error);
      process.exit(1);
    }
  }

  getResults() {
    return this.results;
  }

  exportResults(filename = 'load-test-results.json') {
    const fs = require('fs');
    const data = {
      timestamp: new Date().toISOString(),
      testSuite: 'Ticket Microservice Load Test',
      results: this.results
    };
    
    fs.writeFileSync(filename, JSON.stringify(data, null, 2));
    console.log(`📄 Results exported to: ${filename}`);
  }
}

// CLI execution
if (require.main === module) {
  const args = process.argv.slice(2);
  const tester = new LoadTester();
  
  async function main() {
    try {
      if (args.includes('--full')) {
        await tester.runFullTestSuite();
      } else if (args.includes('--event')) {
        const eventId = parseInt(args[args.indexOf('--event') + 1]) || 1;
        const connections = parseInt(args[args.indexOf('--connections') + 1]) || 5000;
        const duration = parseInt(args[args.indexOf('--duration') + 1]) || 30;
        
        await tester.runPurchaseLoadTest(eventId, { connections, duration });
      } else if (args.includes('--multi')) {
        const eventIds = args.includes('--events') 
          ? args[args.indexOf('--events') + 1].split(',').map(Number)
          : [1, 2, 3];
        const connections = parseInt(args[args.indexOf('--connections') + 1]) || 6000;
        const duration = parseInt(args[args.indexOf('--duration') + 1]) || 30;
        
        await tester.runMultiEventLoadTest(eventIds, { connections, duration });
      } else {
        console.log('🎯 Ticket Microservice Load Tester');
        console.log('Usage:');
        console.log('  node tests/load-test.js --full                    # Run full test suite');
        console.log('  node tests/load-test.js --event 1 --connections 5000 --duration 30');
        console.log('  node tests/load-test.js --multi --events 1,2,3 --connections 6000');
        console.log('');
        console.log('Running default single event test...');
        await tester.runPurchaseLoadTest(1);
      }
      
      if (args.includes('--export')) {
        tester.exportResults();
      }
      
    } catch (error) {
      console.error('Test execution failed:', error);
      process.exit(1);
    }
  }
  
  main();
}

module.exports = LoadTester;