Generación Automatizada de Tests con Claude Code: Guía Práctica

// What Claude actually gave me
vi.mock('../utils/fetchUser')
vi.mock('../utils/validateInput')
vi.mock('../lib/database')

it('should work', () => {
  expect(mockFetchUser).toHaveBeenCalled()
})

## Testing Policy

### Tools
- Test runner: Vitest
- Assertions: Vitest built-in (expect)
- Mocking: vi.fn(), vi.spyOn() — minimal use only
- Coverage: @vitest/coverage-v8

### Test Writing Rules
1. Only mock external I/O (DB, HTTP APIs, file system)
2. Do NOT mock utility functions or pure functions
3. Test names follow the format: "when X, it returns Y"
4. Always include edge cases (empty arrays, null, boundary values)
5. Place test files next to the implementation (`*.test.ts`)

### Coverage Thresholds
- statements: 80%
- branches: 75%
- functions: 80%
- lines: 80%

### Prohibited
- Using `as any`
- Testing implementation details (internal variable names, private methods)
- Modifying production code solely to make tests pass

Write Vitest tests for `src/utils/calculateDiscount.ts`.

This function has no external dependencies. Do not use mocks.
It's a pure function — test input/output combinations exhaustively.

Make sure to cover these cases:
- discountRate is 0
- discountRate is 1.0 (100% off)
- price is 0
- price is negative (expect an error)

Use the format "when [condition], it returns [result]" for all test names.

import { describe, it, expect } from 'vitest'
import { calculateDiscount } from './calculateDiscount'

describe('calculateDiscount', () => {
  describe('valid inputs', () => {
    it('when discountRate is 0.2, it returns 80% of the price', () => {
      expect(calculateDiscount(1000, 0.2)).toBe(800)
    })

    it('when discountRate is 0, it returns the original price', () => {
      expect(calculateDiscount(1000, 0)).toBe(1000)
    })

    it('when discountRate is 1.0, it returns 0', () => {
      expect(calculateDiscount(1000, 1.0)).toBe(0)
    })
  })

  describe('boundary values', () => {
    it('when price is 0, it returns 0', () => {
      expect(calculateDiscount(0, 0.2)).toBe(0)
    })
  })

  describe('error cases', () => {
    it('when price is negative, it throws an Error', () => {
      expect(() => calculateDiscount(-100, 0.2)).toThrow('Price must be non-negative')
    })

    it('when discountRate exceeds 1, it throws an Error', () => {
      expect(() => calculateDiscount(1000, 1.5)).toThrow('Discount rate must be between 0 and 1')
    })
  })
})

Based on the spec below, write Vitest tests. Do NOT write the implementation yet.

Spec:
- Create a `parseJapaneseDate(str: string): Date` function
- It converts strings like "2026年2月26日" into Date objects
- It throws InvalidDateError for malformed input
- Timezone is fixed to JST (UTC+9)

npx vitest run src/utils/parseJapaneseDate.test.ts

Write an implementation that makes all tests in
`src/utils/parseJapaneseDate.test.ts` pass.
Do not modify the tests — solve it on the implementation side only.

npx vitest --watch src/utils/parseJapaneseDate.test.ts

{
  "scripts": {
    "test": "vitest",
    "test:watch": "vitest --watch",
    "test:ui": "vitest --ui",
    "test:coverage": "vitest run --coverage"
  }
}

import { defineConfig } from 'vitest/config'

export default defineConfig({
  test: {
    coverage: {
      provider: 'v8',
      reporter: ['text', 'json', 'html'],
      thresholds: {
        statements: 80,
        branches: 75,
        functions: 80,
        lines: 80,
      },
      exclude: [
        'node_modules/**',
        'src/**/*.d.ts',
        'src/**/*.stories.tsx',
        'src/app/**', // Exclude Next.js App Router pages
      ],
    },
  },
})

# .github/workflows/test.yml
name: Test

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      - run: npm ci
      - run: npm run test:coverage
      - name: Upload coverage
        uses: codecov/codecov-action@v4
        with:
          files: ./coverage/coverage-final.json

# Capture test output
npx vitest run 2>&1 | tee /tmp/test-output.txt

Here's the test failure log. Please fix the implementation code.
Do NOT modify any test files.

---
[paste /tmp/test-output.txt contents here]
---

File to fix: src/utils/parseJapaneseDate.ts

{
  "scripts": {
    "test:fix": "vitest run 2>&1 | claude 'Tests are failing. Fix only the implementation files to make them pass. Do not touch test files.'"
  }
}

Write a Playwright test for the following user story:

User story:
- User navigates to the login page
- User fills in email and password, clicks Submit
- User is redirected to the dashboard
- Page title reads "Dashboard"

Constraints:
- Base URL: http://localhost:3000
- Test user: test@example.com / password123
- Use data-testid selectors only (no class names or id attributes)

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

test.describe('Login feature', () => {
  test('redirects to dashboard with valid credentials', async ({ page }) => {
    await page.goto('/login')

    await page.getByTestId('email-input').fill('test@example.com')
    await page.getByTestId('password-input').fill('password123')
    await page.getByTestId('submit-button').click()

    await expect(page).toHaveURL('/dashboard')
    await expect(page).toHaveTitle('Dashboard')
  })
})

This utility function has no side effects.
Do NOT use vi.mock(). Test it directly.

Before writing any tests, explain which dependencies you'll mock and why.
Wait for my approval before writing the implementation.

## When to Mock

Mock these:
- Database connections
- External HTTP APIs
- File system operations
- Email/SMS sending

Do NOT mock these:
- Pure functions (input/output only, no side effects)
- Date processing (except Date.now())
- String and number operations
- Array and object manipulation