TypeScript เขียนเทสต์



Vitest — รัน TS ได้เลย

npm install --save-dev vitest
// package.json
{
  "scripts": {
    "test": "vitest",
    "test:run": "vitest run"
  }
}

Vitest ใช้ esbuild strip type — รัน .ts ได้ทันที ไม่ต้อง config (Jest ต้อง ts-jest / babel-jest)

เทสต์แรก

// math.ts
export function add(a: number, b: number): number {
  return a + b;
}

export function divide(a: number, b: number): number {
  if (b === 0) throw new Error("หารด้วยศูนย์");
  return a / b;
}
// math.test.ts
import { describe, it, expect } from "vitest";
import { add, divide } from "./math.js";

describe("add", () => {
  it("บวกเลขบวก", () => {
    expect(add(2, 3)).toBe(5);
  });

  it("บวกเลขลบ", () => {
    expect(add(-1, -1)).toBe(-2);
  });
});

describe("divide", () => {
  it("หารปกติ", () => {
    expect(divide(10, 2)).toBe(5);
  });

  it("หารด้วยศูนย์ throw", () => {
    expect(() => divide(1, 0)).toThrow("หารด้วยศูนย์");
  });
});
npm test

matcher ที่ใช้บ่อย

expect(value).toBe(5);                    // === (primitive)
expect(obj).toEqual({ a: 1 });            // deep equality
expect(obj).toStrictEqual({ a: 1 });      // deep + type + undefined
expect(arr).toContain("item");
expect(arr).toHaveLength(3);
expect(value).toBeNull();
expect(value).toBeUndefined();
expect(value).toBeDefined();
expect(value).toBeTruthy();
expect(str).toMatch(/pattern/);
expect(obj).toHaveProperty("user.name", "อร");
expect(() => fn()).toThrow(SomeError);
await expect(promise).resolves.toBe(42);
await expect(promise).rejects.toThrow();

table-driven test — it.each

it.each([
  { a: 2, b: 3, expected: 5 },
  { a: -1, b: 1, expected: 0 },
  { a: 0, b: 0, expected: 0 },
])("add($a, $b) = $expected", ({ a, b, expected }) => {
  expect(add(a, b)).toBe(expected);
});

setup / teardown

import { beforeEach, afterEach, beforeAll } from "vitest";

describe("UserService", () => {
  let service: UserService;

  beforeEach(() => {
    service = new UserService(new InMemoryRepo());
  });

  afterEach(() => {
    vi.restoreAllMocks();
  });

  it("...", () => { });
});

mock function

import { vi, it, expect } from "vitest";

it("เรียก callback ด้วย argument ที่ถูก", () => {
  const callback = vi.fn();                    // vi.fn(): Mock

  processItems([1, 2, 3], callback);

  expect(callback).toHaveBeenCalledTimes(3);
  expect(callback).toHaveBeenCalledWith(1);
  expect(callback).toHaveBeenNthCalledWith(2, 2);
});

it("mock return value", () => {
  const fetchUser = vi.fn<[number], Promise<User>>()
    .mockResolvedValue({ id: 1, name: "อร" });

  // ...
});

mock module

import { vi } from "vitest";
import { sendEmail } from "./email.js";

vi.mock("./email.js");   // ทุก export กลายเป็น vi.fn()

it("ส่งอีเมลต้อนรับหลังสมัคร", async () => {
  vi.mocked(sendEmail).mockResolvedValue(undefined);

  await registerUser({ email: "a@b.com", name: "อร" });

  expect(sendEmail).toHaveBeenCalledWith("a@b.com", expect.stringContaining("ยินดีต้อนรับ"));
});

vi.mocked(fn) — cast ให้ TS รู้ว่าเป็น mock (มี .mockResolvedValue ฯลฯ)

test dependency ด้วย fake แทน mock

structural typing ทำให้ fake ง่าย:

interface UserRepository {
  findById(id: string): Promise<User | null>;
  save(user: User): Promise<void>;
}

class FakeUserRepository implements UserRepository {
  private users = new Map<string, User>();

  async findById(id: string) {
    return this.users.get(id) ?? null;
  }
  async save(user: User) {
    this.users.set(user.id, user);
  }
}

it("...", async () => {
  const repo = new FakeUserRepository();
  const service = new UserService(repo);
  // ...
});

fake มักดีกว่า mock — พฤติกรรมจริง, refactor-safe

type-level testing

ทดสอบว่า type ทำงานถูก (ไม่ใช่ runtime):

import { expectTypeOf, it } from "vitest";

it("type ของ parseAge", () => {
  expectTypeOf(parseAge).returns.toEqualTypeOf<Result<number, string>>();
  expectTypeOf(parseAge).parameter(0).toBeString();
});

// หรือด้วย @ts-expect-error
it("compile error เมื่อส่ง type ผิด", () => {
  // @ts-expect-error - direction ต้องเป็น literal ที่กำหนด
  move("diagonal");
});

@ts-expect-error — บรรทัดถัดไป ต้อง มี type error (ถ้าไม่มี → test fail) ทดสอบว่า type คุ้มครองจริง

expectTypeOf / assertType — assert type ตรงกัน (compile-time)

libraries: expect-type, tsd, type-fest‘s test utils

coverage

npm install --save-dev @vitest/coverage-v8
npx vitest run --coverage
// vitest.config.ts
import { defineConfig } from "vitest/config";

export default defineConfig({
  test: {
    coverage: {
      provider: "v8",
      thresholds: { lines: 80, functions: 80 },
    },
  },
});

เรื่องที่คนมักพลาด

  • ใช้ Jest กับ TS โดยไม่ตั้ง transform — ต้อง ts-jest/@swc/jest; Vitest ไม่ต้อง
  • vi.mock หลัง import — hoisting: vi.mock ถูกยกขึ้นบนสุด แต่ต้องเป็น top-level
  • mock แล้วไม่ vi.mocked() — TS ไม่รู้ว่ามี .mockResolvedValue
  • toBe กับ object — toBe เช็ค === (reference); ใช้ toEqual/toStrictEqual
  • ไม่ await expect(promise).rejects... — Promise assertion ต้อง await
  • @ts-expect-error ที่ไม่มี error จริง — Vitest/tsc fail (ดี — จับกรณีที่ type คุ้มครองหลุด)
  • mock มากเกินไป — เทสต์เปราะ; ใช้ fake (structural typing)

สรุป

  • Vitest — รัน .ts ได้เลย (esbuild), describe/it/expect, it.each (table-driven)
  • matcher: toBe (===), toEqual (deep), toThrow, resolves/rejects
  • mock: vi.fn() (+ vi.mocked ให้ TS รู้), vi.mock("./mod") (module)
  • fake (class Fake implements Repo) มักดีกว่า mock — structural typing ทำให้ง่าย
  • type-level test: expectTypeOf(...), // @ts-expect-error (บรรทัดถัดไปต้อง error)
  • @vitest/coverage-v8 + thresholds

บทถัดไปว่าด้วย ESLint และ Prettier — typescript-eslint, type-aware rules และ config ที่แนะนำ