See What I Build

tests/
├── fixtures/
│   ├── base.fixture.ts       # Custom test fixtures (auth, API client)
│   └── test-data.fixture.ts  # Test data factories
├── pages/
│   ├── BasePage.ts            # Shared page methods
│   ├── LoginPage.ts           # Page Object Model
│   └── DashboardPage.ts
├── api/
│   ├── ApiClient.ts           # Typed API wrapper
│   └── endpoints/
├── e2e/
│   ├── auth.spec.ts           # E2E test suites
│   └── checkout.spec.ts
├── utils/
│   ├── schema-validator.ts    # OpenAPI validation
│   └── db-client.ts           # Direct DB assertions
└── playwright.config.ts       # Multi-env, parallel, Allure

import { Page, Locator, expect } from '@playwright/test';

export class LoginPage {
  private readonly email: Locator;
  private readonly password: Locator;
  private readonly submit: Locator;

  constructor(private page: Page) {
    this.email = page.getByLabel('Email');
    this.password = page.getByLabel('Password');
    this.submit = page.getByRole('button', { name: 'Sign in' });
  }

  async login(email: string, pass: string) {
    await this.email.fill(email);
    await this.password.fill(pass);
    await this.submit.click();
  }
}

export default defineConfig({
  testDir: './tests',
  fullyParallel: true,
  retries: process.env.CI ? 2 : 0,
  workers: process.env.CI ? 4 : undefined,
  reporter: [['html'], ['allure-playwright'], ['github']],
  use: {
    baseURL: process.env.BASE_URL || 'http://localhost:3000',
    trace: 'on-first-retry',
    screenshot: 'only-on-failure',
  },
  projects: [
    { name: 'setup', testMatch: '**/*.setup.ts' },
    { name: 'chromium', use: devices['Desktop Chrome'], dependencies: ['setup'] },
    { name: 'mobile', use: devices['iPhone 14'], dependencies: ['setup'] },
  ],
});

# PR opens → parallel quality gates → merge allowed

name: PR Quality Gates
on:
  pull_request:
    types: [opened, synchronize]
concurrency:
  group: pr-${{ github.event.pull_request.number }}
  cancel-in-progress: true

jobs:
  lint-and-types:        # Stage 1: Fast checks
    runs-on: ubuntu-latest
    steps:
      - run: npm run lint && npm run typecheck

  unit-tests:             # Stage 1: Parallel with lint
    steps:
      - run: npm run test:unit -- --coverage
      - uses: codecov/codecov-action@v4

  e2e-tests:              # Stage 2: After lint passes
    needs: [lint-and-types]
    strategy:
      matrix:
        shard: [1/4, 2/4, 3/4, 4/4]  # 4x parallel
    steps:
      - run: npx playwright test --shard=${{ matrix.shard }}

services:
  app:
    build: { context: ., target: test }
    environment:
      - DATABASE_URL=postgresql://test:test@db:5432/testdb
    depends_on:
      db: { condition: service_healthy }

  db:
    image: postgres:16-alpine
    healthcheck:
      test: ["CMD", "pg_isready"]
      interval: 5s
      retries: 5

import http from 'k6/http';
import { check, sleep } from 'k6';
import { Rate, Trend } from 'k6/metrics';

const errorRate = new Rate('errors');
const apiLatency = new Trend('api_latency');

export const options = {
  stages: [
    { duration: '1m',  target: 50 },   // Warm up
    { duration: '3m',  target: 200 },  // Peak
    { duration: '2m',  target: 200 },  // Sustain
    { duration: '1m',  target: 0 },    // Cool down
  ],
  thresholds: {
    'http_req_duration': ['p(95)<500'],  // p95 under 500ms
    'errors':            ['rate<0.05'],  // <5% error rate
  },
};

export default function () {
  const res = http.get(`${__ENV.BASE_URL}/api/products`);
  apiLatency.add(res.timings.duration);
  errorRate.add(res.status !== 200);
  check(res, {
    'status 200': (r) => r.status === 200,
    'fast response': (r) => r.timings.duration < 500,
  });
  sleep(1);
}

import { McpServer } from '@modelcontextprotocol/sdk/server';

const server = new McpServer({
  name: 'qa-assistant',
  version: '1.0.0',
});

// Tool: Generate tests from source code
server.tool(
  'generate-tests',
  'Analyze source and generate Playwright tests',
  { filePath: { type: 'string' }, testType: { type: 'string' } },
  async ({ filePath, testType }) => {
    const source = await readFile(filePath);
    const conventions = await loadTestConventions();
    return {
      content: [{ type: 'text', text: buildPrompt(source, conventions, testType) }],
    };
  }
);

// Resource: Expose team conventions to AI
server.resource(
  'conventions',
  'qa://conventions',
  async () => ({
    contents: [{ uri: 'qa://conventions', text: await loadTestConventions() }],
  })
);

# .cursor/rules — AI prompt hinting for test quality

When writing Playwright tests, follow these conventions:

Structure:
- Use Page Object Model for all page interactions
- One spec file per feature area
- Group related tests with describe blocks
- Use getByRole, getByLabel, getByTestId — never CSS selectors

Assertions:
- Always assert visible state before interaction
- Use toBeVisible() not toExist()
- Prefer toHaveText() over toContainText() for exact matches
- Add timeout assertions for async operations

Anti-patterns to flag:
- No hardcoded waits (page.waitForTimeout)
- No test interdependence — each test must be isolated
- No shared mutable state between tests
- No selectors based on class names or CSS

Data:
- Use test data factories, never hardcoded values
- Clean up test data in afterEach hooks
- Use API shortcuts for setup, UI for assertions

export function detectFlaky(history: TestHistory[]): string[] {
  return history
    .filter((t) => {
      const rate = t.results
        .filter(r => r === 'pass').length / t.results.length;
      return rate > 0.2 && rate < 0.95;  // Inconsistent = flaky
    })
    .map(t => t.name);
}

// Smart retry — only retry on known flaky patterns
export const retryConfig = {
  shouldRetry(error: Error): boolean {
    const flakyPatterns = [
      /timeout/i,
      /ECONNRESET/,
      /navigation interrupted/i,
    ];
    return flakyPatterns.some(p => p.test(error.message));
  },
};

interface BugReport {
  source: 'automated' | 'manual' | 'user-reported';
  area: string;          // feature area from stacktrace
  frequency: number;     // times reported in 30 days
  userImpact: number;    // affected users count
}

function autoTriage(bug: BugReport): Priority {
  // P0: Data loss or security issue
  if (bug.area.match(/auth|payment|data/)) return 'P0';

  // P1: High frequency + many users affected
  if (bug.frequency > 5 && bug.userImpact > 100) return 'P1';

  // P2: Recurring but lower impact
  if (bug.frequency > 2) return 'P2';

  return 'P3';
}

// Auto-assign to feature owner from CODEOWNERS
async function autoAssign(bug: BugReport) {
  const owner = await getCodeOwner(bug.area);
  await linear.updateIssue(bug.id, {
    assigneeId: owner,
    priority: autoTriage(bug),
  });
}