Belajar NestJS - Testing & Quality Assurance

#Pendahuluan

Aplikasi tanpa test adalah bom waktu. NestJS dirancang dengan testing sebagai prioritas — dependency injection membuat penggantian dependensi dengan mock menjadi sangat mudah. Episode 17 membahas unit test, integration test, dan E2E test untuk membangun kebiasaan menulis test yang menjaga kualitas kode.

#Unit Testing dengan Jest

#Setup Test

Nest CLI sudah mengonfigurasi Jest saat membuat project. Untuk menjalankan test:

npm run test

Jest menemukan file dengan akhiran .spec.ts dan menjalankannya — panggil lewat npm run test.

#Menulis Unit Test untuk Service

Unit test fokus pada satu unit — misalnya sebuah service, dengan dependensi di-mock:

Unit test untuk UsersService

import { Test } from "@nestjs/testing";
import { UsersService } from "./users.service";
 
describe("UsersService", () => {
  let service: UsersService;
 
  beforeEach(async () => {
    const moduleRef = await Test.createTestingModule({
      providers: [UsersService],
    }).compile();
 
    service = moduleRef.get(UsersService);
  });
 
  it("harus mengembalikan daftar user", () => {
    const result = service.findAll();
    expect(result).toContain("Arman");
  });
});

Test.createTestingModule membuat module testing yang mirip dengan runtime. it dan expect adalah API bawaan Jest.

#Mocking Dependensi

Saat service bergantung pada repository, ganti dependensi asli dengan useValue:

Mocking repository

const mockRepo = {
  find: jest.fn().mockResolvedValue([{ id: 1, name: "Arman" }]),
};
 
const moduleRef = await Test.createTestingModule({
  providers: [UsersService, { provide: "UserRepository", useValue: mockRepo }],
}).compile();

Dengan useValue, dependensi asli diganti mock — test menjadi cepat dan terisolasi dari database.

#Integration Testing dengan @nestjs/testing

#Testing Module Penuh

Integration test menggabungkan beberapa komponen nyata — controller, service, dan module — sambil tetap meng-mock dependensi eksternal seperti database.

Integration test controller + service

describe("UsersController", () => {
  let controller: UsersController;
 
  beforeEach(async () => {
    const moduleRef = await Test.createTestingModule({
      controllers: [UsersController],
      providers: [
        UsersService,
        { provide: "UserRepository", useValue: mockRepo },
      ],
    }).compile();
 
    controller = moduleRef.get(UsersController);
  });
 
  it("harus mengembalikan user", async () => {
    const result = await controller.findAll();
    expect(result).toHaveLength(1);
  });
});

#Override Provider

NestJS menyediakan .overrideProvider().useValue() untuk mengganti provider saat test — berguna saat menguji module penuh tanpa menjalankan dependensi yang berat.

#E2E Testing

#Testing End-to-End

E2E test mem-bootstrap seluruh aplikasi dan mengirim request HTTP nyata memakai supertest:

Setup E2E test

import * as request from "supertest";
import { Test } from "@nestjs/testing";
import { INestApplication } from "@nestjs/common";
import { AppModule } from "../src/app.module";
 
describe("App (e2e)", () => {
  let app: INestApplication;
 
  beforeEach(async () => {
    const moduleRef = await Test.createTestingModule({
      imports: [AppModule],
    }).compile();
 
    app = moduleRef.createNestApplication();
    await app.init();
  });
 
  it("GET / mengembalikan Hello World", () => {
    return request(app.getHttpServer())
      .get("/")
      .expect(200)
      .expect("Hello World!");
  });
});

Jalankan dengan npm run test:e2e. File E2E berada di folder test/ dengan akhiran .e2e-spec.ts.

#Test Database Setup

Untuk E2E yang menyentuh database, gunakan database test terpisah atau in-memory:

Database in-memory untuk test

TypeOrmModule.forRoot({
  type: "sqlite",
  database: ":memory:",
  autoLoadEntities: true,
  synchronize: true,
})

Setiap test dimulai dengan database bersih, hasil test jadi deterministik dan cepat.

#Code Coverage, Linting, dan Static Analysis

#Code Coverage

Jest menghitung seberapa banyak kode yang diuji:

npm run test -- --coverage

Laporan coverage menunjukkan baris yang belum diuji. Target sehat biasanya 80 persen ke atas untuk kode penting.

#Linting dan Static Analysis

NestJS menggunakan ESLint dan TypeScript compiler untuk menangkap masalah sejak awal:

npm run lint

Lint menangkap kesalahan gaya dan bug umum. Tambahan seperti TypeScript strict mode dan tipe yang tepat memberi lapisan static analysis tambahan sebelum kode berjalan.

#Penutup

Episode 17 membangun budaya testing. Inti yang harus dibawa pulang:

• Test.createTestingModule membuat module testing seperti runtime.
• Unit test mem-fokus satu unit dan meng-mock dependensi.
• E2E test mengirim request HTTP nyata dengan supertest.
• Database in-memory membuat test cepat dan deterministik.
• Coverage, ESLint, dan TypeScript strict menjaga kualitas kode.