PulseLoad — Live Event Ticketing Platform

import http from 'k6/http';
import { check, sleep, group } from 'k6';
import { Rate, Trend } from 'k6/metrics';

// Custom metrics
const errorRate = new Rate('errors');
const ticketPurchaseTime = new Trend('ticket_purchase_duration');
const paymentLatency = new Trend('payment_latency');

export const options = {
  stages: [
    { duration: '2m', target: 1000 },    // 1K users
    { duration: '2m', target: 5000 },    // 5K users
    { duration: '2m', target: 25000 },   // 25K users
    { duration: '2m', target: 50000 },   // 50K users (peak)
    { duration: '2m', target: 250000 },  // 250K users (extreme)
    { duration: '2m', target: 0 },       // Ramp down
  ],
  thresholds: {
    'http_req_duration': ['p(95)<2000', 'p(99)<3000'], // p95 < 2s, p99 < 3s
    'errors': ['rate<0.001'], // Error rate < 0.1%
    'http_req_failed': ['rate<0.01'], // HTTP failure rate < 1%
  },
};

export default function() {
  const eventId = 'CONCERT-2025-MAJOR';
  const userId = `user-${__VU}-${__ITER}`;

  group('Browse Events', function() {
    const browseRes = http.get(`${__ENV.BASE_URL}/api/v1/events/${eventId}`);
    check(browseRes, {
      'event page status 200': (r) => r.status === 200,
      'response time < 500ms': (r) => r.timings.duration < 500,
    });
  });

  group('Search Available Seats', function() {
    const searchRes = http.post(`${__ENV.BASE_URL}/api/v1/seats/search`, 
      JSON.stringify({
        event_id: eventId,
        section: 'A',
        price_range: [50, 500]
      }),
      { headers: { 'Content-Type': 'application/json' } }
    );
    check(searchRes, {
      'search status 200': (r) => r.status === 200,
      'seats found': (r) => JSON.parse(r.body).seats.length > 0,
    });
  });

  sleep(Math.random() * 2 + 1); // User browsing delay

  group('Reserve Seat (Race Condition Prone)', function() {
    const startTime = new Date();
    const reserveRes = http.post(`${__ENV.BASE_URL}/api/v1/seats/reserve`,
      JSON.stringify({
        event_id: eventId,
        seat_id: 'SEAT-A-001',
        user_id: userId
      }),
      { headers: { 'Content-Type': 'application/json' } }
    );
    const duration = new Date() - startTime;
    
    check(reserveRes, {
      'reservation status 200 or 409': (r) => r.status === 200 || r.status === 409,
      'reservation response < 1s': (r) => r.timings.duration < 1000,
    });
    
    if (reserveRes.status !== 200) {
      errorRate.add(1);
      return; // Seat taken, exit flow
    }
  });

  sleep(1);

  group('Process Payment', function() {
    const paymentStart = new Date();
    const paymentRes = http.post(`${__ENV.BASE_URL}/api/v1/checkout/payment`,
      JSON.stringify({
        event_id: eventId,
        amount: 150.00,
        currency: 'USD',
        payment_method: 'credit_card'
      }),
      { 
        headers: { 
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${__ENV.AUTH_TOKEN}`
        } 
      }
    );
    const paymentDuration = new Date() - paymentStart;
    paymentLatency.add(paymentDuration);
    
    check(paymentRes, {
      'payment status 200': (r) => r.status === 200,
      'payment confirms within 2s': (r) => r.timings.duration < 2000,
    });
  });

  sleep(Math.random() + 0.5);
}

import http from 'k6/http';
import { check } from 'k6';
import { Counter } from 'k6/metrics';

const doubleBookAttempts = new Counter('double_book_attempts');
const successfulReservations = new Counter('successful_reservations');

export const options = {
  vus: 50, // 50 concurrent users
  duration: '30s',
  rps: 1000, // 1000 requests per second
};

export default function() {
  const seatId = 'SEAT-LIMITED-STOCK-001'; // Single seat with 10 available
  const eventId = 'CONCERT-2025';
  
  // Simulate 50 users racing to reserve the same seat
  const reserveRes = http.post(
    `${__ENV.BASE_URL}/api/v1/seats/reserve`,
    JSON.stringify({
      event_id: eventId,
      seat_id: seatId,
      quantity: 1,
      user_id: `user-${__VU}`
    }),
    { headers: { 'Content-Type': 'application/json' } }
  );

  const responseBody = JSON.parse(reserveRes.body);
  
  if (reserveRes.status === 200) {
    successfulReservations.add(1);
  } else if (reserveRes.status === 409) {
    // Expected: seat sold out
    check(reserveRes, {
      'conflict response on sold out': (r) => r.status === 409,
    });
  } else if (reserveRes.status === 500) {
    // ERROR: Double-booking detected
    doubleBookAttempts.add(1);
    console.error(`DOUBLE-BOOKING DETECTED: User ${__VU} got status 500`);
  }
  
  check(reserveRes, {
    'no server errors': (r) => r.status < 500,
  });
}

export function handleSummary(data) {
  // Alert if any double-books detected
  const doubleBooks = data.metrics.double_book_attempts.value;
  if (doubleBooks > 0) {
    console.error(`⚠️  CRITICAL: ${doubleBooks} potential double-bookings detected!`);
  }
  const successful = data.metrics.successful_reservations.value;
  console.log(`✓ Successful reservations: ${successful}`);
}