Cara Menulis Kode yang Mudah Di-test Sejak Awal Tanpa Framework Testing Khusus

Testing bukan tentang framework, tetapi cara berpikir

Banyak developer menunda belajar testing karena merasa kodenya belum siap. Padahal kode yang mudah di-test dimulai dari cara menulis fungsi sejak awal, bukan dari framework testing yang dipilih. Artikel ini membahas prinsip-prinsip yang membuat kode lebih testable.

1. Pure function: output hanya bergantung pada input

Fungsi yang pure tidak bergantung pada state luar dan tidak menghasilkan side effect. Fungsi seperti ini sangat mudah di-test karena outputnya selalu sama untuk input yang sama.

// Tidak testable: bergantung pada state luar
function getDiscountedPrice() {
  return currentPrice * (1 - globalDiscount);
}

// Testable: semua input eksplisit
function getDiscountedPrice(price, discountRate) {
  return price * (1 - discountRate);
}

2. Pisahkan logic dari side effect

Side effect seperti HTTP request, database query, atau manipulasi DOM susah di-test secara langsung. Pisahkan logic bisnis dari side effect.

// Logic bisnis yang murni dan testable
function buildArticlePayload(formData, authorId) {
  return {
    title: formData.title.trim(),
    slug: formData.title.toLowerCase().replace(/\s+/g, '-'),
    authorId,
    publishedAt: new Date().toISOString(),
  };
}

// Side effect dipisah
async function publishArticle(formData, authorId) {
  const payload = buildArticlePayload(formData, authorId);
  return await apiClient.post('/articles', payload);
}

3. Satu fungsi, satu tanggung jawab

Fungsi yang melakukan terlalu banyak hal sulit di-test karena kamu perlu menyiapkan banyak kondisi sekaligus. Pecah menjadi fungsi-fungsi kecil yang masing-masing punya satu tanggung jawab jelas.

4. Dependency injection

Daripada membuat dependency di dalam fungsi, masukkan sebagai parameter. Ini memudahkan penggantian dependency dengan mock saat testing.

// Sulit di-test: database langsung di dalam fungsi
async function getUserProfile(userId) {
  return await prisma.user.findUnique({ where: { id: userId } });
}

// Mudah di-test: database diinjeksikan
async function getUserProfile(userId, db) {
  return await db.user.findUnique({ where: { id: userId } });
}

5. Hindari global state yang tersembunyi

Global state seperti variabel module-level yang berubah-ubah membuat test bisa saling mempengaruhi. Gunakan state yang dibawa melalui parameter atau context yang jelas.

6. Mulai dengan test manual yang terstruktur

Kalau belum pakai framework testing, bisa mulai dengan test manual yang terstruktur. Tulis fungsi kecil dan verifikasi outputnya di console. Kebiasaan berpikir seperti ini akan sangat membantu ketika kamu mulai menggunakan Jest atau Vitest.

// Test manual sederhana
const result = getDiscountedPrice(100000, 0.2);
console.assert(result === 80000, `Expected 80000, got ${result}`);

Kesimpulan

Kode yang mudah di-test adalah kode yang sudah dirancang dengan baik: fungsi kecil, pure jika memungkinkan, dependency yang eksplisit, dan side effect yang terisolasi. Mulai dari prinsip ini dan kamu akan siap menggunakan framework testing apapun tanpa perubahan besar pada arsitektur kode.