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

Fixtures — Trái tim của Playwright Test

Fixture thay thế beforeEach/afterEach và lớp base: test.extend, setup/teardown bao quanh use(), phạm vi test và worker, fixture tự động, option, và ghép nhiều bộ fixture.

Fixturestest.extendWorker scopeDI
📌 Vì sao module này quan trọng

Nếu chỉ được học sâu một tính năng của Playwright Test, hãy chọn fixture. Đây là cơ chế tiêm phụ thuộc của framework: test khai báo nó cần gì (một trang đã đăng nhập, một đơn hàng có sẵn, một API client), framework lo dựng, cấp, và dọn — đúng thứ tự, chỉ khi cần, kể cả khi test fail. Các dự án không dùng fixture thường kết thúc với beforeEach dài 60 dòng chép qua lại, lớp BaseTest kế thừa nhiều tầng, và dữ liệu rác không được dọn. Fixture giải quyết cả ba.

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

  • Viết fixture với test.extend và hiểu vòng đời setup → use → teardown
  • Chọn đúng phạm vi: test-scoped hay worker-scoped
  • Dùng fixture tự động, fixture option, và ghi đè fixture có sẵn
  • Tổ chức fixture theo miền và ghép bằng mergeTests
  • Biết khi nào dùng fixture, khi nào dùng hook, khi nào dùng hàm thường

Từ beforeEach sang fixture

// TRƯỚC — hook: biến dùng chung, setup chạy cho MỌI test dù có cần hay không
let cartPage: CartPage;
let product: Product;

test.beforeEach(async ({ page, request }) => {
  product = await createProduct(request);
  cartPage = new CartPage(page);
  await cartPage.goto();
});
test.afterEach(async ({ request }) => {
  await deleteProduct(request, product.id);       // không chạy nếu beforeEach lỗi giữa chừng
});

// SAU — fixture: khai báo một lần, dùng ở bất kỳ file nào, chỉ chạy khi test yêu cầu
// fixtures/index.ts
import { test as base } from '@playwright/test';

type Fixtures = {
  product: Product;
  cartPage: CartPage;
};

export const test = base.extend<Fixtures>({
  product: async ({ request }, use) => {
    const product = await createProduct(request);   // setup
    await use(product);                              // ← test chạy ở đây
    await deleteProduct(request, product.id);        // teardown: luôn chạy, kể cả khi test fail
  },

  cartPage: async ({ page }, use) => {
    const cartPage = new CartPage(page);
    await cartPage.goto();
    await use(cartPage);
  },
});
export { expect } from '@playwright/test';

// tests/cart.spec.ts
import { test, expect } from '@fixtures';

test('thêm sản phẩm vào giỏ', async ({ cartPage, product }) => {
  await cartPage.add(product.name);
  await expect(cartPage.itemCount).toHaveText('1');
});

test('giỏ trống hiển thị gợi ý', async ({ cartPage }) => {   // không yêu cầu product → không tạo
  await expect(cartPage.emptyState).toBeVisible();
});
Hook (beforeEach/afterEach)Fixture
Chạy khiMọi test trong phạm viChỉ test nào yêu cầu (lười)
Setup và teardownTách hai nơi, dễ lệchCùng một chỗ, bao quanh use()
Tái sử dụng giữa các fileChép lại hoặc import hàmTự có ở mọi nơi import test
Phụ thuộc lẫn nhauTự sắp thứ tựFramework tự phân giải theo tham số
Kiểu dữ liệuBiến let dùng chung, có thể chưa gánCó kiểu, luôn được khởi tạo

Vòng đời và phụ thuộc giữa các fixture

Fixture có thể yêu cầu fixture khác; Playwright dựng theo thứ tự phụ thuộc và dọn theo thứ tự ngược lại:

export const test = base.extend<Fixtures>({
  customer: async ({ api }, use) => {
    const customer = await api.users.create(newUser());
    await use(customer);
    await api.users.delete(customer.id);
  },

  // order phụ thuộc customer và product → hai cái đó được dựng trước, dọn sau
  order: async ({ api, customer, product }, use) => {
    const order = await api.orders.create({ customerId: customer.id, items: [{ sku: product.sku, quantity: 1 }] });
    await use(order);
    await api.orders.delete(order.id);
  },
});

test('khách xem được đơn của mình', async ({ page, order }) => {
  // chỉ khai báo order; customer và product tự được dựng
});
  • Mọi thứ sau use() là teardown và chạy cả khi test fail hay timeout — nơi đáng tin cậy để dọn dữ liệu.
  • Luôn gọi use() đúng một lần. Quên gọi thì test treo.
  • Lỗi trong setup làm test fail với thông báo chỉ rõ fixture nào; phần teardown của fixture đó không chạy, nhưng các fixture đã dựng xong trước đó vẫn được dọn.
  • Thời gian của fixture tính vào timeout của test, trừ khi đặt riêng: [fn, { timeout: 60_000 }].
  • Dùng test.step hoặc { title, box: true } để bước của fixture hiện gọn trong báo cáo.

Phạm vi worker: dựng một lần, dùng cho nhiều test

type WorkerFixtures = {
  workerAccount: Account;
};

export const test = base.extend<Fixtures, WorkerFixtures>({
  // Mỗi worker một tài khoản riêng: các test trong cùng worker dùng chung, các worker không đụng nhau
  workerAccount: [async ({ playwright }, use, workerInfo) => {
    const api = await playwright.request.newContext({ baseURL: env.BASE_URL });
    const account = await createAccount(api, {
      email: `e2e-w${workerInfo.parallelIndex}-${Date.now()}@test.local`,
    });
    await use(account);
    await deleteAccount(api, account.id);
    await api.dispose();
  }, { scope: 'worker' }],
});
Test-scoped (mặc định)Worker-scoped
DựngMỗi testMột lần cho mỗi worker
Cô lậpHoàn toànChia sẻ giữa các test trong worker
Dùng choPage object, dữ liệu của riêng testThứ đắt và dùng chung an toàn: tài khoản, kết nối DB, server giả lập
Dùng được fixture nàoMọi fixtureChỉ fixture worker khác (browser, playwright) — không có page, context, request

workerInfo.parallelIndex (0 đến số worker − 1) là chìa khoá để phân vùng tài nguyên dùng chung: mỗi worker một tài khoản, một schema database, một cổng. Lưu ý: khi một test fail, Playwright khởi động lại worker để đảm bảo sạch — fixture worker sẽ được dựng lại, nên đừng giả định nó chỉ chạy đúng N lần.

Fixture tự động, option, và ghi đè

type Options = { locale: 'vi' | 'en'; featureFlags: Record<string, boolean> };

export const test = base.extend<Fixtures & Options>({
  // 1. Option: giá trị cấu hình được, đặt trong config hoặc test.use()
  locale: ['vi', { option: true }],
  featureFlags: [{}, { option: true }],

  // 2. Auto: chạy cho MỌI test dù không được nhắc tên
  failOnConsoleError: [async ({ page }, use, testInfo) => {
    const errors: string[] = [];
    page.on('console', msg => { if (msg.type() === 'error') errors.push(msg.text()); });
    page.on('pageerror', err => errors.push(err.message));
    await use();
    if (errors.length) {
      await testInfo.attach('console-errors', { body: errors.join('\n'), contentType: 'text/plain' });
      expect.soft(errors, 'Trang có lỗi JavaScript').toEqual([]);
    }
  }, { auto: true }],

  // 3. Ghi đè fixture có sẵn: mọi page đều được chuẩn bị trước
  page: async ({ page, featureFlags }, use) => {
    await page.addInitScript(flags => { (window as any).__FLAGS__ = flags; }, featureFlags);
    await page.route(/google-analytics|hotjar|intercom/, route => route.abort());   // chặn bên thứ ba
    await use(page);
  },
});

// Dùng option
test.describe('giao diện thanh toán mới', () => {
  test.use({ featureFlags: { newCheckout: true } });
  test('hiển thị bước xác nhận', async ({ page }) => { ... });
});

Ba mẫu trên giải quyết ba nhu cầu rất phổ biến: tham số hoá (chạy cùng test với cấu hình khác nhau, kể cả theo project), kiểm tra xuyên suốt (lỗi console, request thất bại, vi phạm accessibility) mà không sửa từng test, và chuẩn bị môi trường thống nhất cho mọi page. Fixture tự động rất mạnh nhưng vô hình — ghi lại chúng trong README của bộ test để người mới không ngạc nhiên.

Tổ chức fixture khi dự án lớn

// fixtures/api.fixture.ts      → export const test = base.extend<ApiFixtures>({ api, ... })
// fixtures/pages.fixture.ts    → export const test = base.extend<PageFixtures>({ cartPage, checkoutPage, ... })
// fixtures/data.fixture.ts     → export const test = base.extend<DataFixtures>({ customer, product, order })

// fixtures/index.ts — điểm import duy nhất
import { mergeTests, mergeExpects } from '@playwright/test';
import { test as apiTest } from './api.fixture';
import { test as pagesTest } from './pages.fixture';
import { test as dataTest } from './data.fixture';
import { expect as moneyExpect } from './matchers';

export const test = mergeTests(apiTest, pagesTest, dataTest);
export const expect = mergeExpects(moneyExpect);

Chặn import trực tiếp từ @playwright/test trong thư mục tests/ bằng quy tắc ESLint no-restricted-imports, để không ai vô tình dùng test gốc thiếu fixture.

Cần gìDùng
Tài nguyên có setup + teardown, dùng ở nhiều fileFixture
Thao tác chung cho mọi test, không trả về gìFixture auto
Chuẩn bị chỉ dùng trong một describe, không tái sử dụngbeforeEach là đủ
Hàm tính toán thuần, không có vòng đờiHàm thường trong utils/
Việc làm một lần cho cả lần chạy (đăng nhập, seed)Setup project (Module 7, 10)
⚠️ Fixture quá tay

Dấu hiệu lạm dụng: fixture bọc một dòng code; test phải khai báo 9 fixture; fixture checkedOutOrderWithCouponAndGiftWrap chỉ một test dùng. Fixture nên mô tả tài nguyên (một khách hàng, một đơn hàng), còn biến thể cụ thể thì để test tự chỉnh qua factory hoặc option.

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

Chuyển dự án sang kiến trúc fixture

(1) Chuyển mọi beforeEach/afterEach dùng chung thành fixture; mục tiêu là không còn biến let cấp file. (2) Viết bộ fixture dữ liệu có phụ thuộc (customer → order) với teardown dọn dẹp; cố ý làm test fail và xác nhận dữ liệu vẫn được xoá. (3) Viết một fixture worker-scoped tạo tài khoản riêng cho mỗi worker dùng parallelIndex; chạy với --workers=4 và kiểm tra có đúng 4 tài khoản. (4) Viết fixture auto bắt lỗi console và request trả 5xx, đính kèm vào báo cáo. (5) Thêm một fixture option cho feature flag và chạy cùng một file test ở hai cấu hình. (6) Tách fixture theo miền, ghép bằng mergeTests, và thêm quy tắc ESLint chặn import trực tiếp @playwright/test trong tests/.

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

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

  • Viết được fixture có setup và teardown bao quanh use()
  • Phân biệt và dùng đúng test-scoped và worker-scoped
  • Có fixture auto cho kiểm tra xuyên suốt và fixture option cho tham số hoá
  • Fixture được tách theo miền và ghép bằng mergeTests; spec chỉ import từ fixtures/
  • Không còn biến let cấp file và beforeEach chép lặp