Testing Lanjutan di TypeScript: Mocking, Coverage Report, dan Integration Testing dengan Jest/Vitest

Testing lanjutan di TypeScript membantu developer meningkatkan kualitas aplikasi dengan menguji skenario kompleks secara realistis. Setelah memahami dasar unit test, langkah selanjutnya adalah belajar bagaimana melakukan mocking, memantau coverage report, dan menulis integration test. Semua ini bertujuan agar pengujian lebih menyeluruh dan hasil aplikasi lebih andal.

Dengan kekuatan sistem tipe TypeScript, testing lanjutan menjadi lebih aman karena setiap mock, fungsi, dan dependensi tetap mengikuti kontrak tipe yang sudah ditetapkan. Framework seperti Jest dan Vitest menyediakan fitur bawaan untuk mendukung testing canggih, sehingga developer dapat fokus pada logika aplikasi tanpa harus menulis konfigurasi yang rumit.

Pentingnya Testing Lanjutan dalam TypeScript

Dalam proyek besar, pengujian dasar seperti unit test saja tidak cukup. Kamu perlu menguji bagaimana modul saling berinteraksi, bagaimana sistem menangani dependensi eksternal, serta memastikan seluruh bagian aplikasi berjalan konsisten.

Testing lanjutan mencakup tiga hal penting:

Mocking: Menggantikan dependensi eksternal (seperti API atau database) agar test tetap cepat dan terisolasi.
Coverage Report: Mengukur seberapa banyak kode yang telah diuji.
Integration Testing: Menguji alur logika dari beberapa modul sekaligus agar berfungsi secara keseluruhan.

Mocking di TypeScript dengan Jest dan Vitest

Mocking memungkinkan kamu membuat tiruan dari fungsi atau modul agar tidak tergantung pada faktor eksternal. Hal ini penting untuk menjaga test tetap deterministik dan cepat.

Contoh mocking di Jest:

// api.ts
export async function getUser(id: number) {
  const res = await fetch(`https://api.example.com/users/${id}`);
  return res.json();
}

// user.test.ts
import { getUser } from "./api";

global.fetch = jest.fn(() =>
  Promise.resolve({
    json: () => Promise.resolve({ id: 1, name: "Arva" }),
  })
) as jest.Mock;

test("mengambil data user dengan mocking", async () => {
  const user = await getUser(1);
  expect(user.name).toBe("Arva");
});

Mocking di Vitest hampir serupa:

import { vi, test, expect } from "vitest";
import { getUser } from "./api";

vi.stubGlobal("fetch", vi.fn(() =>
  Promise.resolve({
    json: () => Promise.resolve({ id: 2, name: "Tici" }),
  })
));

test("mock API di Vitest", async () => {
  const user = await getUser(2);
  expect(user.name).toBe("Tici");
});

Kedua pendekatan ini memastikan test berjalan tanpa perlu koneksi internet atau API asli, sehingga proses testing menjadi cepat dan stabil.

Coverage Report: Mengukur Cakupan Pengujian

Coverage report menunjukkan seberapa besar bagian kode yang telah diuji. Semakin tinggi angkanya, semakin besar jaminan bahwa kode telah diverifikasi secara menyeluruh.

Menjalankan coverage report di Jest:

npm test -- --coverage

Hasilnya akan menampilkan laporan seperti:

File           | % Stmts | % Branch | % Funcs | % Lines
api.ts         |   90    |   85     |   100   |   92

Untuk Vitest, kamu bisa menggunakan plugin c8:

npm install --save-dev c8
npx vitest run --coverage

Dengan laporan coverage, tim pengembang bisa mengetahui bagian mana dari kode yang belum diuji dan memperbaikinya untuk meningkatkan kualitas software.

Integration Testing di TypeScript

Integration testing menguji bagaimana beberapa modul bekerja bersama. Ini penting karena bug sering muncul ketika komponen saling berinteraksi, bukan saat berdiri sendiri.

Contoh sederhana:

// services/userService.ts
import { getUser } from "../api";
export async function getUserName(id: number): Promise<string> {
  const user = await getUser(id);
  return user.name;
}

// tests/userService.test.ts
import { vi, test, expect } from "vitest";
import * as api from "../api";

vi.spyOn(api, "getUser").mockResolvedValue({ id: 1, name: "Arvi" });

test("integration test antara api dan service", async () => {
  const name = await api.getUser(1).then(user => user.name);
  expect(name).toBe("Arvi");
});

Dalam contoh di atas, kita tidak hanya menguji satu fungsi, tetapi aliran data dari API hingga ke service. Ini adalah bentuk integration test sederhana yang umum dipakai di proyek nyata.

Tips Testing Lanjutan TypeScript

Agar testing lanjutan lebih optimal, ikuti beberapa tips berikut:

Gunakan mock terpisah di folder __mocks__ untuk manajemen yang rapi.
Aktifkan strict di tsconfig.json agar pengecekan tipe lebih ketat.
Gunakan beforeEach untuk inisialisasi state test agar hasilnya konsisten.
Gunakan coverage minimal 80% untuk menjaga kualitas.
Gunakan integration atau e2e folder untuk memisahkan test kompleks.

Kesimpulan

Testing lanjutan di TypeScript membantu developer memastikan aplikasi tidak hanya berfungsi di level fungsi kecil, tetapi juga dalam integrasi antar modul. Dengan menggunakan Jest atau Vitest, proses mocking, coverage analysis, dan integration testing menjadi lebih efisien dan kuat.

TypeScript memberikan keuntungan besar dalam hal keamanan tipe dan konsistensi test. Dengan kombinasi ini, kamu dapat membangun sistem yang tangguh, mudah di-maintain, dan siap untuk skala produksi tanpa khawatir akan bug tersembunyi.