Browser
  └── BrowserContext  (isolated session: cookies, localStorage, auth state)
        └── Page      (single tab / top-level frame)
              └── Frame (iframe, default is main frame)

// tests/pages/LoginPage.ts
import { type Page, type Locator } from '@playwright/test'

export class LoginPage {
  private readonly emailInput: Locator
  private readonly passwordInput: Locator
  private readonly submitButton: Locator

  constructor(private readonly page: Page) {
    this.emailInput = page.getByLabel('Email')
    this.passwordInput = page.getByLabel('Password')
    this.submitButton = page.getByRole('button', { name: 'Sign in' })
  }

  async goto() {
    await this.page.goto('/login')
  }

  async login(email: string, password: string) {
    await this.emailInput.fill(email)
    await this.passwordInput.fill(password)
    await this.submitButton.click()
  }
}

// tests/auth.spec.ts
import { test, expect } from '@playwright/test'
import { LoginPage } from './pages/LoginPage'

test('user can sign in with valid credentials', async ({ page }) => {
  const loginPage = new LoginPage(page)
  await loginPage.goto()
  await loginPage.login('user@example.com', 'password123')
  await expect(page).toHaveURL('/dashboard')
  await expect(page.getByRole('heading', { name: 'Dashboard' })).toBeVisible()
})

import { test, expect } from '@playwright/test'

test('shows error when API returns 500', async ({ page }) => {
  await page.route('**/api/users', (route) =>
    route.fulfill({
      status: 500,
      contentType: 'application/json',
      body: JSON.stringify({ error: 'Internal server error' }),
    })
  )

  await page.goto('/users')
  await expect(page.getByRole('alert')).toHaveText('Something went wrong.')
})

test('intercepts and modifies response', async ({ page }) => {
  await page.route('**/api/products', async (route) => {
    const response = await route.fetch()
    const json = await response.json()
    // Inject a test product at the top
    json.items.unshift({ id: 'test-1', name: 'Injected Product' })
    await route.fulfill({ response, json })
  })

  await page.goto('/products')
  await expect(page.getByText('Injected Product')).toBeVisible()
})

import { test, expect } from '@playwright/test'

test('homepage matches snapshot', async ({ page }) => {
  await page.goto('/')
  // Full-page screenshot comparison
  await expect(page).toHaveScreenshot('homepage.png', {
    fullPage: true,
    threshold: 0.2, // 20% pixel diff tolerance
  })
})

test('button states match snapshots', async ({ page }) => {
  await page.goto('/design-system/buttons')
  const buttonGroup = page.getByTestId('button-group')
  await expect(buttonGroup).toHaveScreenshot('button-group.png')
})

import { test, expect } from '@playwright/test'

test('POST /api/users creates a user', async ({ request }) => {
  const response = await request.post('/api/users', {
    data: { name: 'Alice', email: 'alice@example.com' },
  })
  expect(response.status()).toBe(201)
  const body = await response.json()
  expect(body).toMatchObject({ name: 'Alice', email: 'alice@example.com' })
  expect(body.id).toBeDefined()
})

test('authenticated API call with shared context', async ({ playwright }) => {
  const apiContext = await playwright.request.newContext({
    baseURL: 'https://api.example.com',
    extraHTTPHeaders: { Authorization: `Bearer ${process.env.API_TOKEN}` },
  })
  const response = await apiContext.get('/me')
  expect(response.ok()).toBeTruthy()
  await apiContext.dispose()
})

// tests/fixtures.ts
import { test as base, expect } from '@playwright/test'
import { LoginPage } from './pages/LoginPage'

type AppFixtures = {
  loginPage: LoginPage
  authenticatedPage: void
}

export const test = base.extend<AppFixtures>({
  loginPage: async ({ page }, use) => {
    const loginPage = new LoginPage(page)
    await use(loginPage)
  },
  // Fixture that logs in before the test and logs out after
  authenticatedPage: async ({ page }, use) => {
    await page.goto('/login')
    await page.getByLabel('Email').fill(process.env.TEST_USER_EMAIL!)
    await page.getByLabel('Password').fill(process.env.TEST_USER_PASSWORD!)
    await page.getByRole('button', { name: 'Sign in' }).click()
    await page.waitForURL('/dashboard')

    await use()  // test runs here

    await page.goto('/logout')
  },
})

export { expect }

// tests/profile.spec.ts
import { test, expect } from './fixtures'

test('user can update profile', { authenticatedPage: undefined }, async ({ page }) => {
  await page.goto('/profile')
  await page.getByLabel('Display name').fill('Alice Updated')
  await page.getByRole('button', { name: 'Save' }).click()
  await expect(page.getByRole('status')).toHaveText('Profile saved.')
})

// playwright.config.ts
import { defineConfig } from '@playwright/test'

export default defineConfig({
  use: {
    // Collect traces on first retry of a failed test
    trace: 'on-first-retry',
    // Or always collect (useful during development):
    // trace: 'on',
  },
})

undefined

> The trace viewer shows a timeline of actions, network requests, console
> logs, screenshots, and DOM snapshots for every step - making it the fastest
> way to diagnose a failing test without adding `console.log` statements.

undefined

```typescript
// playwright.config.ts
import { defineConfig, devices } from '@playwright/test'

export default defineConfig({
  testDir: './tests',
  fullyParallel: true,
  retries: process.env.CI ? 2 : 0,
  workers: process.env.CI ? 1 : undefined,
  reporter: [['html'], ['github']],
  use: {
    baseURL: process.env.BASE_URL ?? 'http://localhost:3000',
    trace: 'on-first-retry',
  },
  projects: [
    { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
    { name: 'firefox', use: { ...devices['Desktop Firefox'] } },
    { name: 'webkit', use: { ...devices['Desktop Safari'] } },
    { name: 'mobile-chrome', use: { ...devices['Pixel 5'] } },
  ],
})