Belajar Performance Test Engineer - Test Data & Scenarios

#Pendahuluan

Setelah di episode 11 kita memahami capacity planning, kini saatnya membahas komponen yang sering dilupakan tetapi sangat menentukan akurasi hasil test: test data dan scenarios. Load test dengan data yang tidak realistis akan menghasilkan metrik yang menyesatkan — kalian mungkin menemukan bottleneck yang tidak ada di production, atau melewatkan bottleneck yang sebenarnya.

Test data yang baik harus mencerminkan distribusi data production: beberapa produk populer yang banyak diakses, banyak produk yang jarang dilihat, data yang terdistribusi secara tidak merata. Skenario yang baik harus meniru perilaku user nyata — bukan hanya request acak.

#Test Data Management

#Data Volume

Jumlah data mempengaruhi performa secara langsung. Database dengan 1 juta baris berperilaku sangat berbeda dari yang hanya 100 baris — terutama untuk query yang melibatkan full scan atau sorting.

-- Cek ukuran data
SELECT
  relname AS table_name,
  pg_size_pretty(pg_total_relation_size(relid)) AS total_size
FROM pg_catalog.pg_statio_user_tables
ORDER BY pg_total_relation_size(relid) DESC
LIMIT 10;

#Realistic Data Distribution

Data production hampir selalu tidak merata (skewed). Beberapa produk populer mendapatkan 80% traffic; beberapa user aktif melakukan lebih banyak transaksi. Test data harus mencerminkan distribusi ini.

// k6: data distribution dengan weighted random
import { SharedArray } from 'k6/data';
 
const products = new SharedArray('products', function () {
  return JSON.parse(open('./products.json'));
  // products.json berisi products dengan weight property
});
 
export default function () {
  // 70% request ke top 10 products (hot data)
  // 30% request ke remaining products (cold data)
  const product = products[Math.floor(Math.random() * products.length)];
  http.get(`https://api.example.com/products/${product.id}`);
}

#Test Data Isolation

Test data harus terisolasi dari data production. Jangan pernah menjalankan load test langsung ke production database — ini bisa merusak data dan mempengaruhi user nyata.

# Buat test database dari production snapshot
pg_dump production_db | psql test_db
 
# Atau gunakan database terpisah untuk test
createdb perf_test_db

#Membangun Realistic Scenarios

#User Journey Mapping

Sebelum menulis scripts, pahami bagaimana user benar-benar menggunakan aplikasi:

1. Browse products: halaman utama → kategori → detail produk
2. Search: input query → hasil pencarian → klik produk
3. Add to cart: detail produk → add to cart → checkout
4. Checkout: cart → payment → confirmation
5. Account management: login → profil → orders

Setiap journey punya distribution berbeda: mungkin 60% user hanya browse, 30% add to cart, 10% checkout. Scripts harus mencerminkan distribusi ini.

#Weighted User Types

import { group } from 'k6';
 
export const options = {
  scenarios: {
    browsers: {
      executor: 'constant-vus',
      vus: 60,
      duration: '5m',
      exec: 'browseScenario',
    },
    shoppers: {
      executor: 'constant-vus',
      vus: 30,
      duration: '5m',
      exec: 'shopScenario',
    },
    buyers: {
      executor: 'constant-vus',
      vus: 10,
      duration: '5m',
      exec: 'buyScenario',
    },
  },
};
 
export function browseScenario() {
  group('Browse', function () {
    http.get('https://api.example.com/products');
    sleep(3);
    http.get('https://api.example.com/products/1');
    sleep(2);
  });
}
 
export function shopScenario() {
  group('Shop', function () {
    http.get('https://api.example.com/search?q=widget');
    sleep(2);
    http.post('https://api.example.com/cart', JSON.stringify({ productId: 1 }));
    sleep(1);
  });
}
 
export function buyScenario() {
  group('Buy', function () {
    http.post('https://api.example.com/checkout', JSON.stringify({
      items: [{ productId: 1, quantity: 2 }],
    }));
  });
}

#Synthetic Data Generation

#Mengapa Synthetic Data?

Production data mungkin mengandung informasi sensitif (PII) yang tidak boleh dipakai untuk testing. Synthetic data adalah data buatan yang mempertahankan distribusi dan karakteristik data production tanpa mengandung informasi asli.

#Tools Synthetic Data

• Faker.js: data names, addresses, emails yang realistis
• Mockaroo: generate dataset dalam format JSON/CSV
• Custom scripts: untuk data spesifik aplikasi

// Generate synthetic user data
import { SharedArray } from 'k6/data';
import { randomIntBetween } from 'k6/utils';
 
const users = new SharedArray('users', function () {
  const data = [];
  for (let i = 0; i < 10000; i++) {
    data.push({
      id: i,
      name: `user-${i}`,
      email: `user${i}@test.example.com`,
      tier: ['free', 'pro', 'enterprise'][randomIntBetween(0, 2)],
    });
  }
  return data;
});

#Data-Driven Testing

#Parameterized Tests

Gunakan data yang berbeda untuk setiap iterasi test — ini mengungkap bottleneck yang hanya muncul dengan data tertentu:

export default function () {
  const queries = ['laptop', 'phone', 'tablet', 'monitor', 'keyboard'];
  const query = queries[__ITER % queries.length];
  http.get(`https://api.example.com/search?q=${query}`);
}

#Correlation dengan Production Patterns

Untuk menghasilkan test yang akurat, kalian perlu memahami pola production:

• Peak hours: kapan traffic paling tinggi?
• User distribution: berapa banyak user aktif vs registered?
• Feature usage: fitur mana yang paling sering dipakai?
• Error patterns: error apa yang paling sering terjadi?

#Penutup

Di episode 12 ini kalian telah memahami test data & scenarios:

• Data volume mempengaruhi performa — test dengan data production-scale.
• Data distribution harus realistis — skewed, tidak merata.
• Test data isolation: jangan test langsung ke production.
• User journey mapping: pahami bagaimana user benar-benar menggunakan aplikasi.
• Weighted scenarios: distribusi user types harus mencerminkan traffic nyata.

Di episode 13 selanjutnya, kita akan membahas Distributed Load Testing — bagaimana men-scale load test ke banyak mesin untuk menghasilkan beban yang lebih besar dari satu mesin tidak mampu. Siapkan infrastruktur kalian!