Playwright + TypeScript Thực chiến
Trang chủ / Module 9
🌐 Module 9 / 15 · 1-2 tuần

Network — Mock, Chặn, và API Testing

Chặn và giả lập request bằng page.route, sửa response thật, HAR, test trạng thái lỗi và trạng thái biên, API testing với request fixture, và ranh giới của việc mock.

page.routeMockingHARAPI Testing
📌 Vì sao module này quan trọng

Nhiều trạng thái quan trọng của giao diện gần như không thể tạo ra bằng dữ liệu thật: server trả 500, mạng chậm 10 giây, danh sách rỗng, danh sách 10.000 dòng, cổng thanh toán từ chối. Đó lại là những trạng thái người dùng gặp trong ngày tồi tệ nhất của họ — và hiếm khi được test. Khả năng điều khiển tầng mạng của Playwright biến chúng thành vài dòng code. Nhưng mock cũng là con dao hai lưỡi: mock quá tay thì bộ test xanh mượt trong khi sản phẩm thật đã hỏng. Module này dạy cả kỹ thuật lẫn ranh giới.

🎯 Mục tiêu học tập

  • Dùng page.route để giả lập, sửa, chặn, và làm chậm request
  • Test trạng thái lỗi, rỗng, tải chậm của giao diện một cách tất định
  • Chờ và kiểm tra request/response thật mà không mock
  • Viết API test bằng request fixture và kết hợp API với UI trong một test
  • Quyết định cái gì nên mock, cái gì không, và giữ mock không lệch khỏi API thật

page.route: bốn thao tác cơ bản

// 1. Giả lập hoàn toàn (fulfill): không chạm backend
await page.route('**/api/products?*', route => route.fulfill({
  json: { items: [], total: 0 },
}));

// 2. Sửa response thật (fetch rồi fulfill): giữ phần lớn dữ liệu thật, đổi đúng thứ cần
await page.route('**/api/products/*', async route => {
  const response = await route.fetch();
  const product = await response.json();
  await route.fulfill({ response, json: { ...product, stock: 0 } });       // ép hết hàng
});

// 3. Chặn (abort): bên thứ ba, ảnh nặng, quảng cáo
await page.route(/\.(png|jpg|webp)$/, route => route.abort());
await page.route(/google-analytics|facebook\.net|hotjar/, route => route.abort());

// 4. Sửa request rồi cho đi tiếp (continue)
await page.route('**/api/**', route => route.continue({
  headers: { ...route.request().headers(), 'x-e2e-run': runId },
}));
  • Đăng ký route trước hành động gây ra request — thường là trước page.goto().
  • page.route áp cho một trang; context.route áp cho mọi trang trong context (kể cả popup).
  • Mẫu URL: glob (**/api/orders/*), regex, hoặc hàm. Glob * không khớp dấu /; ** thì có. Chú ý query string — **/api/products không khớp /api/products?page=2.
  • Route đăng ký sau được ưu tiên trước; dùng route.fallback() để chuyển cho handler đăng ký trước đó.
  • Service worker có thể nuốt request trước khi route thấy: đặt serviceWorkers: 'block' trong use khi cần mock.

Test các trạng thái khó tạo

test('hiển thị thông báo và nút thử lại khi tải đơn hàng lỗi', async ({ page }) => {
  let calls = 0;
  await page.route('**/api/orders?*', route => {
    calls++;
    return calls === 1
      ? route.fulfill({ status: 500, json: { message: 'Internal error' } })
      : route.fallback();                                    // lần 2: cho về backend thật
  });

  await page.goto('/orders');
  await expect(page.getByRole('alert')).toContainText('Không tải được danh sách đơn hàng');

  await page.getByRole('button', { name: 'Thử lại' }).click();
  await expect(page.getByRole('table', { name: 'Danh sách đơn hàng' })).toBeVisible();
});

test('hiển thị khung chờ trong lúc tải chậm', async ({ page }) => {
  let release!: () => void;
  const gate = new Promise<void>(resolve => { release = resolve; });

  await page.route('**/api/orders?*', async route => {
    await gate;                                              // giữ request cho tới khi test cho phép
    await route.fallback();
  });

  await page.goto('/orders');
  await expect(page.getByTestId('orders-skeleton')).toBeVisible();     // khẳng định trạng thái đang tải

  release();
  await expect(page.getByTestId('orders-skeleton')).toBeHidden();
});

Mẫu "cổng" ở test thứ hai đáng nhớ: thay vì làm chậm bằng một khoảng thời gian cố định (lại là sleep), test giữ request cho đến khi đã khẳng định xong trạng thái trung gian rồi mới thả. Hoàn toàn tất định.

Trạng thái nên có testCách tạo
Lỗi server (500), lỗi quyền (403), hết phiên (401)fulfill({ status })
Mất mạngroute.abort('internetdisconnected') hoặc context.setOffline(true)
Danh sách rỗng / rất dài / dữ liệu biên (tên cực dài, ký tự đặc biệt)fulfill({ json })
Tải chậm, trạng thái đang xử lýMẫu cổng
Bấm hai lần (double submit)Giữ request đầu, bấm lần hai, đếm số request
Cổng thanh toán/bên thứ ba từ chốiMock response của bên thứ ba

Quan sát request thật mà không mock

// Kiểm tra giao diện gửi đúng payload
const requestPromise = page.waitForRequest(r =>
  r.url().endsWith('/api/orders') && r.method() === 'POST');
await checkoutPage.placeOrderButton.click();
const request = await requestPromise;

expect(request.postDataJSON()).toMatchObject({
  couponCode: 'GIAM10',
  items: [{ sku: product.sku, quantity: 2 }],
});

// Chờ response và kiểm tra — đồng thời là điểm đồng bộ đáng tin cậy
const responsePromise = page.waitForResponse('**/api/orders');
await checkoutPage.placeOrderButton.click();
const response = await responsePromise;
expect(response.status()).toBe(201);
⚠️ Đừng dùng networkidle

waitForLoadState('networkidle') chờ đến khi không có request nào trong 500ms. Với ứng dụng hiện đại (polling, analytics, websocket) nó hoặc không bao giờ đạt, hoặc đạt vào lúc ngẫu nhiên — một nguồn flaky kinh điển. Thay bằng chờ một điều cụ thể: phần tử xuất hiện, hoặc đúng response bạn quan tâm.

HAR: ghi lại và phát lại

// Ghi một lần (update: true), các lần sau phát lại từ file
await page.routeFromHAR('fixtures/har/catalog.har', {
  url: '**/api/catalog/**',
  update: !!process.env.UPDATE_HAR,
  updateContent: 'embed',
});
Mock viết tayHAR
Công tạoCaoThấp — ghi lại từ lần chạy thật
Kiểm soát chi tiếtCaoThấp; file lớn, khó đọc diff
Hợp vớiTrạng thái lỗi và biên cụ thểTrang đọc nhiều dữ liệu, API bên thứ ba chậm/không ổn định
Rủi roLệch khỏi API thậtLệch nhanh hơn; có thể chứa dữ liệu nhạy cảm (token, PII) — phải lọc trước khi commit

API testing với Playwright

// tests/api/orders.api.spec.ts — không mở trình duyệt, chạy rất nhanh
import { test, expect } from '@fixtures';

test.describe('POST /api/orders', () => {
  test('tạo đơn hợp lệ', async ({ request, product }) => {
    const res = await request.post('/api/orders', {
      data: { items: [{ sku: product.sku, quantity: 2 }] },
    });

    expect(res.status()).toBe(201);
    const order = OrderSchema.parse(await res.json());
    expect(order.total).toBe(product.price * 2);
  });

  test('từ chối số lượng vượt tồn kho', async ({ request, product }) => {
    const res = await request.post('/api/orders', {
      data: { items: [{ sku: product.sku, quantity: product.stock + 1 }] },
    });

    expect(res.status()).toBe(422);
    expect(await res.json()).toMatchObject({ code: 'INSUFFICIENT_STOCK' });
  });

  test('không cho xem đơn của người khác', async ({ request, otherCustomerOrder }) => {
    const res = await request.get(`/api/orders/${otherCustomerOrder.id}`);
    expect(res.status()).toBe(404);
  });
});
  • Fixture request dùng chung baseURL, header và storageState với project — tức là đã đăng nhập sẵn với vai trò của project.
  • Tách API test thành project riêng (Module 10): chạy trước, nhanh, và nếu fail thì khỏi chạy E2E.
  • Kết hợp trong một test: thao tác trên UI rồi kiểm chứng qua API (dữ liệu có thật sự được lưu đúng không), hoặc ngược lại — thường cho test vừa nhanh vừa kiểm chứng sâu.
  • Quy tắc kim tự tháp vẫn đúng: logic nghiệp vụ, phân quyền, validation kiểm tra chủ yếu ở tầng API; tầng UI kiểm tra rằng giao diện nối đúng với chúng.

Ranh giới của mock

Nên mockKhông nên mock
Bên thứ ba ngoài tầm kiểm soát: cổng thanh toán, bản đồ, gửi SMS, analyticsBackend của chính bạn trong các test luồng chính — đó là thứ E2E tồn tại để kiểm chứng
Trạng thái lỗi và biên không tạo được bằng dữ liệu thậtLuồng thành công chính của các tính năng cốt lõi
Thứ không tất định: thời gian (dùng page.clock), dữ liệu ngẫu nhiên từ serverThứ có thể dựng bằng API một cách rẻ
Thứ chậm và không liên quan đến điều đang testChính sự tích hợp bạn muốn tin cậy

Hai tầng test UI thường cùng tồn tại:

  • E2E thật (backend thật, chỉ mock bên thứ ba): ít hơn, chậm hơn, tin cậy cao — phủ các hành trình quan trọng.
  • Test UI với backend giả lập: nhiều hơn, nhanh, tất định — phủ trạng thái lỗi, biên, và biến thể giao diện.

Chống lệch mock: sinh kiểu dữ liệu mock từ cùng nguồn với API (OpenAPI/schema dùng chung, hoặc schema zod ở Module 2) để khi API đổi thì mock không biên dịch được; và kết hợp với contract testing (khoá Advanced QA, Module 3). Mock không có gì ràng buộc với API thật sẽ thành lời nói dối sau vài tháng.

🏋️ Bài tập thực hành

Phủ các trạng thái mà dữ liệu thật không tạo được

Chọn một trang quan trọng có tải dữ liệu (danh sách đơn hàng, trang sản phẩm). (1) Viết test cho: lỗi 500 kèm thử lại thành công, 401 chuyển về đăng nhập, danh sách rỗng, mất mạng, và trạng thái đang tải bằng mẫu cổng (không dùng sleep). (2) Viết test chống bấm hai lần cho một nút gửi biểu mẫu: giữ request đầu, bấm lần hai, khẳng định chỉ có một request. (3) Viết test kiểm tra payload giao diện gửi đi cho một biểu mẫu phức tạp. (4) Mock một dịch vụ bên thứ ba ứng dụng đang gọi, cho cả ca thành công và ca từ chối. (5) Viết 8 API test cho một endpoint: hợp lệ, validation, phân quyền, không tìm thấy — đặt trong project riêng. (6) Viết một test lai: tạo qua UI, kiểm chứng qua API. (7) Rà soát mọi chỗ đang mock: cái nào là backend của chính bạn trong luồng chính? Viết kế hoạch gỡ bỏ hoặc ràng buộc bằng schema.

📚 Tài nguyên học tập

✅ Tự đánh giá hoàn thành

  • Dùng thành thạo fulfill, fetch + fulfill, abort, continue, fallback
  • Có test cho trạng thái lỗi, rỗng, mất mạng, và đang tải — không dùng sleep
  • Chờ response/request cụ thể thay cho networkidle
  • Có bộ API test trong project riêng và ít nhất một test lai UI + API
  • Có nguyên tắc thành văn về cái gì được mock, và mock được ràng buộc bằng schema