Framework · Page objects, fixtures and isolated payment data

playwright.config.ts
pages/PaymentPage.ts
fixtures/test.ts
clients/PaymentClient.ts
data/payment-builder.ts
tests/ui/payment.spec.ts
tests/api/refund.spec.ts

// pages/PaymentPage.ts
import type { Page, Locator } from '@playwright/test';
export class PaymentPage {
  readonly status: Locator;
  constructor(private readonly page: Page) {
    this.status = page.getByTestId('payment-status');
  }
  async open(id: string): Promise<void> {
    await this.page.goto(`/payments/${encodeURIComponent(id)}`);
  }
  async requestRefund(amount: string): Promise<void> {
    await this.page.getByLabel('Refund amount').fill(amount);
    await this.page.getByRole('button', { name: 'Request refund', exact: true }).click();
  }
}

// fixtures/test.ts. Test-support reset is hypothetical and sandbox-only.
import { test as base, expect } from '@playwright/test';
import { randomUUID } from 'node:crypto';
import { PaymentPage } from '../pages/PaymentPage';
type OwnedPayment = { id: string };
export const test = base.extend<{ payment: OwnedPayment; paymentPage: PaymentPage }>({
  payment: async ({ request }, use) => {
    const created = await request.post('/test-support/payments', {
      data: { correlation: randomUUID(), amountMinor: 1250, currency: 'GEL', state: 'CAPTURED' },
    });
    expect(created.status()).toBe(201);
    const value: unknown = await created.json();
    if (!value || typeof value !== 'object' || !('id' in value) || typeof value.id !== 'string') {
      throw new Error('Invalid fixture payment id');
    }
    try { await use({ id: value.id }); }
    finally {
      const reset = await request.delete(`/test-support/payments/${encodeURIComponent(value.id)}`);
      expect(reset.status()).toBe(204);
    }
  },
  paymentPage: async ({ page, payment }, use) => {
    const paymentPage = new PaymentPage(page);
    await paymentPage.open(payment.id);
    await use(paymentPage);
  },
});
export { expect };

// tests/ui/payment.spec.ts
import { test, expect } from '../../fixtures/test';
test('owned captured payment is displayed', async ({ paymentPage }) => {
  await expect(paymentPage.status).toHaveText('CAPTURED');
});

// fixtures/worker-api.ts: separate worker-owned context.
import { test as base, request, type APIRequestContext } from '@playwright/test';
export const test = base.extend<{}, { api: APIRequestContext }>({
  api: [async ({}, use) => {
    const baseURL = process.env.BASE_URL;
    if (!baseURL) throw new Error('BASE_URL required');
    const api = await request.newContext({ baseURL });
    try { await use(api); } finally { await api.dispose(); }
  }, { scope: 'worker' }],
});

// Scoped auth-setup test body, page/expect plus mkdirSync from node:fs imported.
const email = process.env.QA_EMAIL;
const password = process.env.QA_PASSWORD;
if (!email || !password) throw new Error('Sandbox QA credentials required');
await page.goto('/login');
await page.getByLabel('Email').fill(email);
await page.getByLabel('Password').fill(password);
await page.getByRole('button', { name: 'Sign in' }).click();
await expect(page).toHaveURL(/\/dashboard/);
mkdirSync('playwright/.auth', { recursive: true });
await page.context().storageState({ path: 'playwright/.auth/user.json' });

import { defineConfig, devices } from '@playwright/test';
export default defineConfig({
  testDir: './tests', timeout: 40_000, expect: { timeout: 7_000 },
  retries: process.env.CI ? 1 : 0, workers: process.env.CI ? 2 : undefined,
  reporter: [['html', { open: 'never' }], ['junit', { outputFile: 'reports/junit.xml' }]],
  use: { baseURL: process.env.BASE_URL ?? 'http://localhost:3000',
    trace: 'on-first-retry', screenshot: 'only-on-failure', video: 'off' },
  projects: [{ name: 'chromium', use: { ...devices['Desktop Chrome'] } }],
});

import { randomUUID } from 'node:crypto';
export function paymentData() {
  const correlation = randomUUID();
  return { amountMinor: 1250, currency: 'GEL', correlation,
    note: `QA-${process.env.CI_PIPELINE_ID ?? 'local'}-${correlation}` };
}