Claude AI Test Case Generation: From PRDs to Executable Tests (2026)

import { calculateDiscount } from './pricing';

describe('calculateDiscount', () => {
  it('applies 10% discount for orders over $100', () => {
    expect(calculateDiscount(150)).toBe(135);
  });

  it('returns original price for orders under $100', () => {
    expect(calculateDiscount(50)).toBe(50);
  });

  it('handles boundary value of exactly $100', () => {
    expect(calculateDiscount(100)).toBe(90);
  });

  it('throws for negative amounts', () => {
    expect(() => calculateDiscount(-10)).toThrow('Amount must be positive');
  });

  it('handles zero correctly', () => {
    expect(calculateDiscount(0)).toBe(0);
  });
});

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

test.describe('POST /api/users', () => {
  test('creates user with valid payload', async ({ request }) => {
    const response = await request.post('/api/users', {
      data: { name: 'Jane Doe', email: 'jane@example.com' }
    });
    expect(response.status()).toBe(201);
    const body = await response.json();
    expect(body.id).toBeDefined();
    expect(body.name).toBe('Jane Doe');
  });

  test('rejects duplicate email with 409', async ({ request }) => {
    const response = await request.post('/api/users', {
      data: { name: 'Jane Doe', email: 'existing@example.com' }
    });
    expect(response.status()).toBe(409);
  });

  test('rejects missing required fields with 400', async ({ request }) => {
    const response = await request.post('/api/users', {
      data: { name: 'Jane Doe' } // missing email
    });
    expect(response.status()).toBe(400);
  });
});

System: You are a Senior QA Engineer with 10 years of experience.
Extract every testable scenario from the PRD below.
For each scenario, generate:
1. Test case ID (TC-001 format)
2. Description
3. Preconditions
4. Test steps
5. Expected result
6. Executable code (Playwright TypeScript)

Categorize as: Positive, Negative, Boundary, Edge Case.

---

PRD: Shopping Cart Feature

Users can add items to their cart from the product listing page.
- Each item shows name, price, and "Add to Cart" button
- Cart icon in header shows item count (badge)
- Maximum 99 items per product
- Minimum order value: $10.00
- Users can update quantity or remove items from cart page
- "Proceed to Checkout" disabled when cart is empty
- Cart persists across page refreshes (localStorage)

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

// TC-001: Positive - Add item to cart
test('TC-001: adding item updates cart badge count', async ({ page }) => {
  await page.goto('/products');
  await page.getByRole('button', { name: 'Add to Cart' }).first().click();
  await expect(page.getByTestId('cart-badge')).toHaveText('1');
});

// TC-002: Boundary - Maximum 99 items per product
test('TC-002: cannot exceed 99 items per product', async ({ page }) => {
  await page.goto('/cart');
  await page.getByLabel('Quantity').fill('100');
  await page.getByLabel('Quantity').press('Tab');
  await expect(page.getByLabel('Quantity')).toHaveValue('99');
});

// TC-003: Negative - Checkout disabled when empty
test('TC-003: checkout button disabled when cart is empty', async ({ page }) => {
  await page.goto('/cart');
  await expect(
    page.getByRole('button', { name: 'Proceed to Checkout' })
  ).toBeDisabled();
});

// TC-004: Boundary - Minimum order value $10
test('TC-004: shows minimum order warning below $10', async ({ page }) => {
  await page.goto('/products');
  // Add a $5 item
  await page.getByText('$5.00').locator('..')
    .getByRole('button', { name: 'Add to Cart' }).click();
  await page.goto('/cart');
  await expect(page.getByText('Minimum order value is $10.00')).toBeVisible();
});

// TC-005: Edge Case - Cart persistence across refresh
test('TC-005: cart persists after page refresh', async ({ page }) => {
  await page.goto('/products');
  await page.getByRole('button', { name: 'Add to Cart' }).first().click();
  await expect(page.getByTestId('cart-badge')).toHaveText('1');
  await page.reload();
  await expect(page.getByTestId('cart-badge')).toHaveText('1');
});

Title: Implement password reset via email
Type: Story | Priority: High | Sprint: 24

Description:
As a user, I want to reset my password via email so that
I can regain access to my account when I forget my password.

Acceptance Criteria:
- User clicks "Forgot Password?" on login page
- User enters their registered email
- System sends a reset link (expires in 1 hour)
- User clicks link, enters new password (min 8 chars,
  1 uppercase, 1 number)
- After reset, user is redirected to login with success message
- Invalid/expired links show an error page
- Rate limit: max 3 reset requests per hour per email

You are a Senior QA Automation Engineer.
Given this Jira ticket, generate:
1. Acceptance test cases (Playwright TypeScript)
2. Negative test cases for each acceptance criterion
3. Edge cases the ticket doesn't explicitly mention

Use getByRole and getByLabel locators. Include test IDs
(PROJ-1234-TC-001 format).

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

test.describe('PROJ-1234: Password Reset', () => {
  // PROJ-1234-TC-001: Happy path
  test('user can reset password via email link', async ({ page }) => {
    await page.goto('/login');
    await page.getByRole('link', { name: 'Forgot Password?' }).click();
    await page.getByLabel('Email').fill('user@example.com');
    await page.getByRole('button', { name: 'Send Reset Link' }).click();
    await expect(page.getByText('Check your email')).toBeVisible();
  });

  // PROJ-1234-TC-002: Negative - unregistered email
  test('shows error for unregistered email', async ({ page }) => {
    await page.goto('/forgot-password');
    await page.getByLabel('Email').fill('unknown@example.com');
    await page.getByRole('button', { name: 'Send Reset Link' }).click();
    await expect(page.getByRole('alert')).toBeVisible();
  });

  // PROJ-1234-TC-003: Negative - weak password
  test('rejects password without uppercase letter', async ({ page }) => {
    await page.goto('/reset-password?token=valid-token');
    await page.getByLabel('New Password').fill('weakpass1');
    await page.getByRole('button', { name: 'Reset Password' }).click();
    await expect(page.getByText(/uppercase/i)).toBeVisible();
  });

  // PROJ-1234-TC-004: Edge - expired link
  test('expired token shows error page', async ({ page }) => {
    await page.goto('/reset-password?token=expired-token');
    await expect(page.getByText(/expired|invalid/i)).toBeVisible();
  });

  // PROJ-1234-TC-005: Edge - rate limiting
  test('rate limits after 3 requests per hour', async ({ page }) => {
    await page.goto('/forgot-password');
    for (let i = 0; i < 4; i++) {
      await page.getByLabel('Email').fill('user@example.com');
      await page.getByRole('button', { name: 'Send Reset Link' }).click();
    }
    await expect(page.getByText(/too many requests/i)).toBeVisible();
  });
});

You are a Senior QA Automation Engineer with 12 years of experience.
You specialize in test case design using boundary value analysis,
equivalence partitioning, and decision table techniques.

When generating tests:
- Always include positive, negative, and edge cases
- Use descriptive test names that explain the scenario
- Use getByRole and getByLabel locators (never CSS selectors)
- Add comments explaining WHY each test exists
- Group related tests in describe blocks
- Follow AAA pattern (Arrange, Act, Assert)

Apply boundary value analysis to this input field:
- Username: 3-20 characters, alphanumeric only

Generate test cases for: minimum (3), minimum-1 (2), minimum+1 (4),
maximum (20), maximum+1 (21), maximum-1 (19), empty string,
and special characters.

For the following feature, generate ONLY negative test cases.
Think about: invalid inputs, missing required fields, unauthorized
access, network failures, race conditions, and malformed data.

Feature: User profile update form
Fields: name (required), email (required, must be valid),
phone (optional, US format), avatar (optional, max 5MB, JPG/PNG)

Think step by step about edge cases the development team likely
missed for this feature. Consider: concurrent users, timezone
differences, locale/i18n, very long inputs, Unicode characters,
browser back button, session expiry mid-flow, and slow network.

Feature: Online exam with 60-minute time limit.
The timer starts when the user clicks "Begin Exam" and the exam
auto-submits when time expires.

Generate a test data factory for the User entity:

interface User {
  name: string;       // 2-50 chars
  email: string;      // valid email format
  age: number;        // 18-120
  role: 'admin' | 'user' | 'moderator';
  bio?: string;       // optional, max 500 chars
}

Create functions: validUser(), invalidUser(), boundaryUser(),
and a table of 10 diverse test records covering edge cases.

Tech stack context for all test generation in this session:

- Framework: Playwright + TypeScript
- Test runner: @playwright/test
- Assertions: expect from @playwright/test
- Patterns: Page Object Model for E2E, fixtures for test data
- Locators: getByRole, getByLabel, getByTestId (in that priority)
- Naming: describe('Feature', () => test('should ...'))
- No CSS selectors. No XPath. No data-cy attributes.
- Base URL configured in playwright.config.ts
- Auth state stored in .auth/ directory via storageState

Feature: Subscription Plan Upgrade/Downgrade

Users on the Settings > Billing page can:
- See their current plan (Free, Pro $19/mo, Enterprise $49/mo)
- Click "Upgrade" or "Downgrade" to change plans
- Confirm plan change in a modal dialog
- See prorated billing calculation before confirming
- Receive confirmation email after plan change
- Changes take effect immediately for upgrades
- Downgrades take effect at end of current billing cycle

API: PUT /api/subscriptions/:userId
Body: { plan: 'free' | 'pro' | 'enterprise' }
Response: { success: boolean, effectiveDate: string, prorated: number }

Business rules:
- Cannot downgrade with unpaid invoices
- Enterprise requires minimum 1-year commitment
- Free plan has 3-project limit

import { calculateProration } from './billing';

describe('calculateProration', () => {
  it('calculates upgrade proration correctly', () => {
    // 15 days remaining, upgrading from Pro ($19) to Enterprise ($49)
    const result = calculateProration({
      currentPlan: 'pro',
      newPlan: 'enterprise',
      daysRemaining: 15,
      billingCycleDays: 30
    });
    expect(result).toBe(15); // ($49-$19) * 15/30 = $15
  });

  it('returns zero for same plan', () => {
    const result = calculateProration({
      currentPlan: 'pro', newPlan: 'pro',
      daysRemaining: 15, billingCycleDays: 30
    });
    expect(result).toBe(0);
  });

  it('returns negative for downgrade (credit)', () => {
    const result = calculateProration({
      currentPlan: 'enterprise', newPlan: 'pro',
      daysRemaining: 20, billingCycleDays: 30
    });
    expect(result).toBeLessThan(0);
  });
});

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

test.describe('PUT /api/subscriptions/:userId', () => {
  test('upgrades plan successfully', async ({ request }) => {
    const res = await request.put('/api/subscriptions/user-123', {
      data: { plan: 'enterprise' }
    });
    expect(res.status()).toBe(200);
    const body = await res.json();
    expect(body.success).toBe(true);
    expect(body.prorated).toBeGreaterThan(0);
  });

  test('rejects downgrade with unpaid invoices', async ({ request }) => {
    const res = await request.put('/api/subscriptions/user-unpaid', {
      data: { plan: 'free' }
    });
    expect(res.status()).toBe(402);
  });

  test('rejects invalid plan name', async ({ request }) => {
    const res = await request.put('/api/subscriptions/user-123', {
      data: { plan: 'platinum' }
    });
    expect(res.status()).toBe(400);
  });
});

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

test.describe('Subscription plan change', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/settings/billing');
  });

  test('displays current plan with upgrade options', async ({ page }) => {
    await expect(page.getByText('Current Plan: Pro')).toBeVisible();
    await expect(
      page.getByRole('button', { name: 'Upgrade to Enterprise' })
    ).toBeVisible();
  });

  test('shows proration in confirmation modal', async ({ page }) => {
    await page.getByRole('button', { name: 'Upgrade to Enterprise' }).click();
    const modal = page.getByRole('dialog');
    await expect(modal).toBeVisible();
    await expect(modal.getByText(/prorated/i)).toBeVisible();
    await expect(modal.getByText(/\$\d+\.\d{2}/)).toBeVisible();
  });

  test('completes upgrade and shows confirmation', async ({ page }) => {
    await page.getByRole('button', { name: 'Upgrade to Enterprise' }).click();
    await page.getByRole('button', { name: 'Confirm Upgrade' }).click();
    await expect(page.getByText('Plan upgraded successfully')).toBeVisible();
    await expect(page.getByText('Current Plan: Enterprise')).toBeVisible();
  });

  test('downgrade shows end-of-cycle effective date', async ({ page }) => {
    await page.getByRole('button', { name: 'Downgrade to Free' }).click();
    await expect(
      page.getByRole('dialog').getByText(/takes effect on/i)
    ).toBeVisible();
  });
});