{
	"test:e2e": "playwright test",
	"test:e2e:ui": "playwright test --ui",
	"test:e2e:ci": "playwright test"
}

"test:e2e": {
	"cache": false
}

git add package.json pnpm-lock.yaml turbo.json
git commit -m "test: add playwright e2e scripts"
git push -u origin feat/e2e-test-plan-2b10

import { defineConfig, devices } from "@playwright/test";

const port = Number.parseInt(process.env.PORT ?? "3000", 10);
const baseURL = process.env.APP_URL ?? `http://127.0.0.1:${port}`;
const isCI = process.env.CI === "true" || process.env.CI === "1";

export default defineConfig({
	testDir: "./tests/e2e/specs",
	fullyParallel: true,
	forbidOnly: isCI,
	retries: isCI ? 2 : 0,
	workers: isCI ? 2 : undefined,
	reporter: isCI
		? [
				["list"],
				["github"],
				["junit", { outputFile: "test-results/e2e-junit.xml" }],
			]
		: [["list"], ["html", { open: "never" }]],
	use: {
		baseURL,
		trace: "retain-on-failure",
		screenshot: "only-on-failure",
		video: "retain-on-failure",
	},
	projects: [
		{
			name: "chromium",
			use: { ...devices["Desktop Chrome"] },
		},
	],
	webServer: {
		command: "pnpm start",
		url: `${baseURL}/api/health`,
		reuseExistingServer: !isCI,
		timeout: 120_000,
		env: {
			...process.env,
			PORT: String(port),
		},
	},
});

git add playwright.config.ts
git commit -m "test: configure playwright"
git push -u origin feat/e2e-test-plan-2b10

import type { TestInfo } from "@playwright/test";

const sanitize = (value: string) => value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");

export type E2EAccount = {
	name: string;
	username: string;
	email: string;
	password: string;
};

export function createRunSlug(testInfo: TestInfo) {
	const worker = testInfo.workerIndex;
	const title = sanitize(testInfo.titlePath.join("-")).slice(0, 40);
	const suffix = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
	return `e2e-${worker}-${title}-${suffix}`;
}

export function createAccount(testInfo: TestInfo): E2EAccount {
	const slug = createRunSlug(testInfo).replaceAll("-", "_").slice(0, 48);
	return {
		name: "E2E Test User",
		username: slug,
		email: `${slug}@example.test`,
		password: "Password123!",
	};
}

export function createResumeName(testInfo: TestInfo) {
	return `E2E Resume ${createRunSlug(testInfo)}`;
}

import { eq, or } from "drizzle-orm";
import { db, getPool } from "@reactive-resume/db/client";
import { user } from "@reactive-resume/db/schema";

export async function deleteE2EUser(account: { email: string; username: string }) {
	await db.delete(user).where(or(eq(user.email, account.email), eq(user.username, account.username)));
}

export async function closeE2EDatabase() {
	await getPool().end();
	globalThis.__pool = undefined;
	globalThis.__drizzle = undefined;
}

import type { Browser, Page } from "@playwright/test";
import type { E2EAccount } from "./data";

export async function registerViaUi(page: Page, account: E2EAccount) {
	await page.goto("/auth/register");
	await page.getByLabel("Name").fill(account.name);
	await page.getByLabel("Username").fill(account.username);
	await page.getByLabel("Email Address").fill(account.email);
	await page.getByLabel("Password").fill(account.password);
	await page.getByRole("button", { name: "Sign up" }).click();
	await page.getByRole("link", { name: /continue/i }).click();
	await page.waitForURL(/\/dashboard/);
}

export async function loginViaUi(page: Page, account: E2EAccount) {
	await page.goto("/auth/login");
	await page.getByLabel(/email|username/i).fill(account.email);
	await page.getByLabel("Password").fill(account.password);
	await page.getByRole("button", { name: "Sign in" }).click();
	await page.waitForURL(/\/dashboard/);
}

export async function createAuthenticatedPage(browser: Browser, account: E2EAccount) {
	const context = await browser.newContext();
	const page = await context.newPage();
	await registerViaUi(page, account);
	return page;
}

import type { Page, TestInfo } from "@playwright/test";
import { expect } from "@playwright/test";
import { createResumeName } from "./data";

export async function createSampleResumeFromDashboard(page: Page, testInfo: TestInfo) {
	const resumeName = createResumeName(testInfo);
	await page.goto("/dashboard/resumes");
	await page.getByText("Create a new resume").click();
	await page.getByRole("dialog", { name: "Create a new resume" }).getByLabel("Name").fill(resumeName);
	await page.getByRole("button", { name: "Create resume with options" }).click();
	await page.getByRole("menuitem", { name: "Create a Sample Resume" }).click();
	await expect(page.getByText(resumeName)).toBeVisible();
	await page.getByText(resumeName).click();
	await page.waitForURL(/\/builder\/.+/);
	return resumeName;
}

export async function openRightSidebarSection(page: Page, name: string) {
	await page.getByRole("button", { name }).click();
}

import { test as base, expect } from "@playwright/test";
import type { E2EAccount } from "./data";
import { createAccount } from "./data";
import { deleteE2EUser } from "./db";
import { registerViaUi } from "./auth";

type Fixtures = {
	account: E2EAccount;
	authPage: import("@playwright/test").Page;
};

export const test = base.extend<Fixtures>({
	account: async ({}, use, testInfo) => {
		const account = createAccount(testInfo);
		await use(account);
		await deleteE2EUser(account);
	},
	authPage: async ({ browser, account }, use) => {
		const context = await browser.newContext();
		const page = await context.newPage();
		await registerViaUi(page, account);
		await use(page);
		await context.close();
	},
});

export { expect };

git add tests/e2e/fixtures
git commit -m "test: add e2e fixtures"
git push -u origin feat/e2e-test-plan-2b10

import { test, expect } from "../fixtures/test";
import { loginViaUi, registerViaUi } from "../fixtures/auth";

test("registers and logs in with email credentials", async ({ page, account }) => {
	await registerViaUi(page, account);
	await expect(page.getByRole("heading", { name: "Resumes" })).toBeVisible();
	await page.getByRole("button", { name: /user menu|account|profile/i }).click();
	await page.getByRole("menuitem", { name: /logout|sign out/i }).click();
	await loginViaUi(page, account);
	await expect(page.getByRole("heading", { name: "Resumes" })).toBeVisible();
});

import { test, expect } from "../fixtures/test";
import { createSampleResumeFromDashboard } from "../fixtures/resume";

test("creates a sample resume and persists a basics edit", async ({ authPage: page }, testInfo) => {
	await createSampleResumeFromDashboard(page, testInfo);
	const updatedName = `E2E Edited ${Date.now()}`;
	await page.getByRole("button", { name: "Basics" }).click();
	await page.getByLabel("Name").fill(updatedName);
	await page.reload();
	await page.getByRole("button", { name: "Basics" }).click();
	await expect(page.getByLabel("Name")).toHaveValue(updatedName);
});

import { test, expect } from "../fixtures/test";
import { createSampleResumeFromDashboard } from "../fixtures/resume";

test("exports and imports a resume JSON backup", async ({ authPage: page }, testInfo) => {
	const resumeName = await createSampleResumeFromDashboard(page, testInfo);
	await page.getByRole("button", { name: "Export" }).click();
	const downloadPromise = page.waitForEvent("download");
	await page.getByRole("button", { name: /^JSON$/ }).click();
	const download = await downloadPromise;
	expect(download.suggestedFilename()).toMatch(/\.json$/);
	const path = await download.path();
	expect(path).toBeTruthy();
	if (!path) throw new Error("Expected Playwright to provide a downloaded JSON path.");
	await page.goto("/dashboard/resumes");
	await page.getByText("Import an existing resume").click();
	await page.getByRole("combobox").click();
	await page.getByRole("option", { name: "Reactive Resume (JSON)" }).click();
	await page.getByText("Click here to select a file to import").setInputFiles(path);
	await page.getByRole("button", { name: "Import" }).click();
	await page.waitForURL(/\/builder\/.+/);
	await expect(page.getByText(resumeName)).toBeVisible();
});

import { test, expect } from "../fixtures/test";
import { createSampleResumeFromDashboard } from "../fixtures/resume";

test("publishes a resume and renders it for an anonymous visitor", async ({ browser, authPage: page }, testInfo) => {
	await createSampleResumeFromDashboard(page, testInfo);
	await page.getByRole("button", { name: "Sharing" }).click();
	await page.getByLabel("Allow Public Access").click();
	const publicUrl = await page.getByLabel("URL").inputValue();
	const anonymous = await browser.newPage();
	await anonymous.goto(publicUrl);
	await expect(anonymous.getByRole("button", { name: /download/i })).toBeVisible();
	await anonymous.close();
});

git add tests/e2e/specs
git commit -m "test: add core e2e specs"
git push -u origin feat/e2e-test-plan-2b10

# E2E Tests

Reactive Resume uses Playwright for PR-gated browser coverage of deterministic core flows.

## Local setup

Start PostgreSQL:

`sudo docker compose -f compose.dev.yml up -d postgres`

Generate local test secrets:

`export AUTH_SECRET=$(openssl rand -hex 32)`

`export ENCRYPTION_SECRET=$(openssl rand -hex 32)`

Run database migrations:

`APP_URL=http://localhost:3000 PORT=3000 DATABASE_URL=postgresql://postgres:postgres@localhost:5432/postgres FLAG_DISABLE_SIGNUPS=false FLAG_DISABLE_EMAIL_AUTH=false FLAG_DISABLE_API_RATE_LIMIT=true LOCAL_STORAGE_PATH=/workspace/data/e2e pnpm db:migrate`

Build the production app:

`APP_URL=http://localhost:3000 PORT=3000 DATABASE_URL=postgresql://postgres:postgres@localhost:5432/postgres FLAG_DISABLE_SIGNUPS=false FLAG_DISABLE_EMAIL_AUTH=false FLAG_DISABLE_API_RATE_LIMIT=true LOCAL_STORAGE_PATH=/workspace/data/e2e pnpm build`

Run tests:

`APP_URL=http://localhost:3000 PORT=3000 DATABASE_URL=postgresql://postgres:postgres@localhost:5432/postgres FLAG_DISABLE_SIGNUPS=false FLAG_DISABLE_EMAIL_AUTH=false FLAG_DISABLE_API_RATE_LIMIT=true LOCAL_STORAGE_PATH=/workspace/data/e2e pnpm test:e2e`

## Coverage

- Email/password auth smoke.
- Dashboard sample resume creation.
- Builder basics edit and autosave persistence.
- JSON export/import.
- Public sharing for anonymous visitors.

PDF, DOCX, OAuth, passkeys, 2FA, password reset, and AI flows are intentionally outside the initial PR gate.

git add tests/e2e/README.md
git commit -m "docs: document e2e workflow"
git push -u origin feat/e2e-test-plan-2b10

name: E2E Tests

on:
  pull_request:
  push:
    branches: ["main"]

permissions:
  contents: read

env:
  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
  APP_URL: http://localhost:3000
  PORT: "3000"
  DATABASE_URL: postgresql://postgres:postgres@localhost:5432/postgres
  FLAG_DISABLE_SIGNUPS: "false"
  FLAG_DISABLE_EMAIL_AUTH: "false"
  FLAG_DISABLE_API_RATE_LIMIT: "true"
  LOCAL_STORAGE_PATH: /tmp/reactive-resume-e2e-storage

jobs:
  e2e:
    runs-on: ubuntu-latest
    timeout-minutes: 30

    services:
      postgres:
        image: postgres:16
        env:
          POSTGRES_DB: postgres
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
        ports:
          - 5432:5432
        options: >-
          --health-cmd "pg_isready -U postgres -d postgres"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:
      - name: Checkout Repository
        uses: actions/checkout@v6
        with:
          persist-credentials: false

      - name: Install pnpm
        uses: pnpm/action-setup@v6

      - name: Setup Node
        uses: actions/setup-node@v6
        with:
          node-version: "24"
          cache: "pnpm"

      - name: Install Dependencies
        run: pnpm install --frozen-lockfile

      - name: Install Playwright Browser
        run: pnpm exec playwright install --with-deps chromium

      - name: Generate Test Secrets
        run: |
          echo "AUTH_SECRET=$(openssl rand -hex 32)" >> "$GITHUB_ENV"
          echo "ENCRYPTION_SECRET=$(openssl rand -hex 32)" >> "$GITHUB_ENV"

      - name: Prepare Storage
        run: mkdir -p "$LOCAL_STORAGE_PATH"

      - name: Run Database Migrations
        run: pnpm db:migrate

      - name: Build
        run: pnpm build

      - name: Run E2E Tests
        run: pnpm test:e2e:ci

      - name: Upload Playwright Report
        if: always()
        uses: actions/upload-artifact@v7
        with:
          name: playwright-report
          path: |
            playwright-report
            test-results
          if-no-files-found: ignore
          retention-days: 7

git add .github/workflows/e2e.yml
git commit -m "ci: run e2e tests on pull requests"
git push -u origin feat/e2e-test-plan-2b10

export AUTH_SECRET=$(openssl rand -hex 32)
export ENCRYPTION_SECRET=$(openssl rand -hex 32)
APP_URL=http://localhost:3000 PORT=3000 DATABASE_URL=postgresql://postgres:postgres@localhost:5432/postgres FLAG_DISABLE_SIGNUPS=false FLAG_DISABLE_EMAIL_AUTH=false FLAG_DISABLE_API_RATE_LIMIT=true LOCAL_STORAGE_PATH=/workspace/data/e2e pnpm build

APP_URL=http://localhost:3000 PORT=3000 DATABASE_URL=postgresql://postgres:postgres@localhost:5432/postgres FLAG_DISABLE_SIGNUPS=false FLAG_DISABLE_EMAIL_AUTH=false FLAG_DISABLE_API_RATE_LIMIT=true LOCAL_STORAGE_PATH=/workspace/data/e2e pnpm test:e2e

git add .
git commit -m "test: stabilize e2e suite"
git push -u origin feat/e2e-test-plan-2b10